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

com.unity.netcode.gameobjects@2.0.0-exp.2

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).

## [2.0.0-exp.2] - 2024-04-02

### Added
- Added updates to all internal messages to account for a distributed authority network session connection.  (#2863)
- Added `NetworkRigidbodyBase` that provides users with a more customizable network rigidbody, handles both `Rigidbody` and `Rigidbody2D`, and provides an option to make `NetworkTransform` use the rigid body for motion.  (#2863)
  - For a customized `NetworkRigidbodyBase` class:
    - `NetworkRigidbodyBase.AutoUpdateKinematicState` provides control on whether the kinematic setting will be automatically set or not when ownership changes.
    - `NetworkRigidbodyBase.AutoSetKinematicOnDespawn` provides control on whether isKinematic will automatically be set to true when the associated `NetworkObject` is despawned.
    - `NetworkRigidbodyBase.Initialize` is a protected method that, when invoked, will initialize the instance. This includes options to:
      - Set whether using a `RigidbodyTypes.Rigidbody` or `RigidbodyTypes.Rigidbody2D`.
      - Includes additional optional parameters to set the `NetworkTransform`, `Rigidbody`, and `Rigidbody2d` to use.
  - Provides additional public methods:
    - `NetworkRigidbodyBase.GetPosition` to return the position of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
    - `NetworkRigidbodyBase.GetRotation` to return the rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
    - `NetworkRigidbodyBase.MovePosition` to move to the position of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
    - `NetworkRigidbodyBase.MoveRotation` to move to the rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
    - `NetworkRigidbodyBase.Move` to move to the position and rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
    - `NetworkRigidbodyBase.Move` to move to the position and rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
    - `NetworkRigidbodyBase.SetPosition` to set the position of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
    - `NetworkRigidbodyBase.SetRotation` to set the rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
    - `NetworkRigidbodyBase.ApplyCurrentTransform` to set the position and rotation of the `Rigidbody` or `Rigidbody2d` based on the associated `GameObject` transform (depending upon its initialized setting).
    - `NetworkRigidbodyBase.WakeIfSleeping` to wake up the rigid body if sleeping.
    - `NetworkRigidbodyBase.SleepRigidbody` to put the rigid body to sleep.
    - `NetworkRigidbodyBase.IsKinematic` to determine if the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting) is currently kinematic.
    - `NetworkRigidbodyBase.SetIsKinematic` to set the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting) current kinematic state.
    - `NetworkRigidbodyBase.ResetInterpolation` to reset the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting) back to its original interpolation value when initialized.
  - Now includes a `MonoBehaviour.FixedUpdate` implementation that will update the assigned `NetworkTransform` when `NetworkRigidbodyBase.UseRigidBodyForMotion` is true. (#2863)
- Added `RigidbodyContactEventManager` that provides a more optimized way to process collision enter and collision stay events as opposed to the `Monobehaviour` approach. (#2863)
  - Can be used in client-server and distributed authority modes, but is particularly useful in distributed authority.
- Added rigid body motion updates to `NetworkTransform` which allows users to set interolation on rigid bodies. (#2863)
  - Extrapolation is only allowed on authoritative instances, but custom class derived from `NetworkRigidbodyBase` or `NetworkRigidbody` or `NetworkRigidbody2D` automatically switches non-authoritative instances to interpolation if set to extrapolation.
- Added distributed authority mode support to `NetworkAnimator`. (#2863)
- Added session mode selection to `NetworkManager` inspector view. (#2863)
- Added distributed authority permissions feature. (#2863)
- Added distributed authority mode specific `NetworkObject` permissions flags (Distributable, Transferable, and RequestRequired). (#2863)
- Added distributed authority mode specific `NetworkObject.SetOwnershipStatus` method that applies one or more `NetworkObject` instance's ownership flags. If updated when spawned, the ownership permission changes are synchronized with the other connected clients. (#2863)
- Added distributed authority mode specific `NetworkObject.RemoveOwnershipStatus` method that removes one or more `NetworkObject` instance's ownership flags. If updated when spawned, the ownership permission changes are synchronized with the other connected clients. (#2863)
- Added distributed authority mode specific `NetworkObject.HasOwnershipStatus` method that will return (true or false) whether one or more ownership flags is set. (#2863)
- Added distributed authority mode specific `NetworkObject.SetOwnershipLock` method that locks ownership of a `NetworkObject` to prevent ownership from changing until the current owner releases the lock. (#2863)
- Added distributed authority mode specific `NetworkObject.RequestOwnership` method that sends an ownership request to the current owner of a spawned `NetworkObject` instance. (#2863)
- Added distributed authority mode specific `NetworkObject.OnOwnershipRequested` callback handler that is invoked on the owner/authoritative side when a non-owner requests ownership. Depending upon the boolean returned value depends upon whether the request is approved or denied. (#2863)
- Added distributed authority mode specific `NetworkObject.OnOwnershipRequestResponse` callback handler that is invoked when a non-owner's request has been processed. This callback includes a `NetworkObjet.OwnershipRequestResponseStatus` response parameter that describes whether the request was approved or the reason why it was not approved. (#2863)
- Added distributed authority mode specific `NetworkObject.DeferDespawn` method that defers the despawning of `NetworkObject` instances on non-authoritative clients based on the tick offset parameter. (#2863)
- Added distributed authority mode specific `NetworkObject.OnDeferredDespawnComplete` callback handler that can be used to further control when deferring the despawning of a `NetworkObject` on non-authoritative instances. (#2863)
- Added `NetworkClient.SessionModeType` as one way to determine the current session mode of the network session a client is connected to. (#2863)
- Added distributed authority mode specific `NetworkClient.IsSessionOwner` property to determine if the current local client is the current session owner of a distributed authority session. (#2863)
- Added distributed authority mode specific client side spawning capabilities. When running in distributed authority mode, clients can instantiate and spawn `NetworkObject` instances (the local client is authomatically the owner of the spawned object). (#2863)
  - This is useful to better visually synchronize owner authoritative motion models and newly spawned `NetworkObject` instances (i.e. projectiles for example).
- Added distributed authority mode specific client side player spawning capabilities. Clients will automatically spawn their associated player object locally. (#2863)
- Added distributed authority mode specific `NetworkConfig.AutoSpawnPlayerPrefabClientSide` property (default is true) to provide control over the automatic spawning of player prefabs on the local client side. (#2863)
- Added distributed authority mode specific `NetworkManager.OnFetchLocalPlayerPrefabToSpawn` callback that, when assigned, will allow the local client to provide the player prefab to be spawned for the local client. (#2863)
  - This is only invoked if the `NetworkConfig.AutoSpawnPlayerPrefabClientSide` property is set to true.
- Added distributed authority mode specific `NetworkBehaviour.HasAuthority` property that determines if the local client has authority over the associated `NetworkObject` instance (typical use case is within a `NetworkBehaviour` script much like that of `IsServer` or `IsClient`). (#2863)
- Added distributed authority mode specific `NetworkBehaviour.IsSessionOwner` property that determines if the local client is the session owner (typical use case would be to determine if the local client can has scene management authority within a `NetworkBehaviour` script). (#2863)
- Added support for distributed authority mode scene management where the currently assigned session owner can start scene events (i.e. scene loading and scene unloading). (#2863)

### Fixed

- Fixed issue where the host was not invoking `OnClientDisconnectCallback` for its own local client when internally shutting down. (#2822)
- Fixed issue where NetworkTransform could potentially attempt to "unregister" a named message prior to it being registered. (#2807)
- Fixed issue where in-scene placed `NetworkObject`s with complex nested children `NetworkObject`s (more than one child in depth) would not synchronize properly if WorldPositionStays was set to true. (#2796)

### Changed
- Changed client side awareness of other clients is now the same as a server or host. (#2863)
- Changed `NetworkManager.ConnectedClients` can now be accessed by both server and clients. (#2863)
- Changed `NetworkManager.ConnectedClientsList` can now be accessed by both server and clients. (#2863)
- Changed `NetworkTransform` defaults to owner authoritative when connected to a distributed authority session. (#2863)
- Changed `NetworkVariable` defaults to owner write and everyone read permissions when connected to a distributed authority session (even if declared with server read or write permissions).  (#2863)
- Changed `NetworkObject` no longer implements the `MonoBehaviour.Update` method in order to determine whether a `NetworkObject` instance has been migrated to a different scene. Instead, only `NetworkObjects` with the `SceneMigrationSynchronization` property set will be updated internally during the `NetworkUpdateStage.PostLateUpdate` by `NetworkManager`. (#2863)
- Changed `NetworkManager` inspector view layout where properties are now organized by category. (#2863)
- Changed `NetworkTransform` to now use `NetworkTransformMessage` as opposed to named messages for NetworkTransformState updates. (#2810)
- Changed `CustomMessageManager` so it no longer attempts to register or "unregister" a null or empty string and will log an error if this condition occurs. (#2807)
This commit is contained in:
Unity Technologies
2024-04-02 00:00:00 +00:00
parent f8ebf679ec
commit 143a6cbd34
140 changed files with 18009 additions and 2672 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
CHANGELOG.md
View File

@@ -6,6 +6,79 @@ 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). Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).
## [2.0.0-exp.2] - 2024-04-02
### Added
- Added updates to all internal messages to account for a distributed authority network session connection. (#2863)
- Added `NetworkRigidbodyBase` that provides users with a more customizable network rigidbody, handles both `Rigidbody` and `Rigidbody2D`, and provides an option to make `NetworkTransform` use the rigid body for motion. (#2863)
- For a customized `NetworkRigidbodyBase` class:
- `NetworkRigidbodyBase.AutoUpdateKinematicState` provides control on whether the kinematic setting will be automatically set or not when ownership changes.
- `NetworkRigidbodyBase.AutoSetKinematicOnDespawn` provides control on whether isKinematic will automatically be set to true when the associated `NetworkObject` is despawned.
- `NetworkRigidbodyBase.Initialize` is a protected method that, when invoked, will initialize the instance. This includes options to:
- Set whether using a `RigidbodyTypes.Rigidbody` or `RigidbodyTypes.Rigidbody2D`.
- Includes additional optional parameters to set the `NetworkTransform`, `Rigidbody`, and `Rigidbody2d` to use.
- Provides additional public methods:
- `NetworkRigidbodyBase.GetPosition` to return the position of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
- `NetworkRigidbodyBase.GetRotation` to return the rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
- `NetworkRigidbodyBase.MovePosition` to move to the position of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
- `NetworkRigidbodyBase.MoveRotation` to move to the rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
- `NetworkRigidbodyBase.Move` to move to the position and rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
- `NetworkRigidbodyBase.Move` to move to the position and rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
- `NetworkRigidbodyBase.SetPosition` to set the position of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
- `NetworkRigidbodyBase.SetRotation` to set the rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
- `NetworkRigidbodyBase.ApplyCurrentTransform` to set the position and rotation of the `Rigidbody` or `Rigidbody2d` based on the associated `GameObject` transform (depending upon its initialized setting).
- `NetworkRigidbodyBase.WakeIfSleeping` to wake up the rigid body if sleeping.
- `NetworkRigidbodyBase.SleepRigidbody` to put the rigid body to sleep.
- `NetworkRigidbodyBase.IsKinematic` to determine if the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting) is currently kinematic.
- `NetworkRigidbodyBase.SetIsKinematic` to set the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting) current kinematic state.
- `NetworkRigidbodyBase.ResetInterpolation` to reset the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting) back to its original interpolation value when initialized.
- Now includes a `MonoBehaviour.FixedUpdate` implementation that will update the assigned `NetworkTransform` when `NetworkRigidbodyBase.UseRigidBodyForMotion` is true. (#2863)
- Added `RigidbodyContactEventManager` that provides a more optimized way to process collision enter and collision stay events as opposed to the `Monobehaviour` approach. (#2863)
- Can be used in client-server and distributed authority modes, but is particularly useful in distributed authority.
- Added rigid body motion updates to `NetworkTransform` which allows users to set interolation on rigid bodies. (#2863)
- Extrapolation is only allowed on authoritative instances, but custom class derived from `NetworkRigidbodyBase` or `NetworkRigidbody` or `NetworkRigidbody2D` automatically switches non-authoritative instances to interpolation if set to extrapolation.
- Added distributed authority mode support to `NetworkAnimator`. (#2863)
- Added session mode selection to `NetworkManager` inspector view. (#2863)
- Added distributed authority permissions feature. (#2863)
- Added distributed authority mode specific `NetworkObject` permissions flags (Distributable, Transferable, and RequestRequired). (#2863)
- Added distributed authority mode specific `NetworkObject.SetOwnershipStatus` method that applies one or more `NetworkObject` instance's ownership flags. If updated when spawned, the ownership permission changes are synchronized with the other connected clients. (#2863)
- Added distributed authority mode specific `NetworkObject.RemoveOwnershipStatus` method that removes one or more `NetworkObject` instance's ownership flags. If updated when spawned, the ownership permission changes are synchronized with the other connected clients. (#2863)
- Added distributed authority mode specific `NetworkObject.HasOwnershipStatus` method that will return (true or false) whether one or more ownership flags is set. (#2863)
- Added distributed authority mode specific `NetworkObject.SetOwnershipLock` method that locks ownership of a `NetworkObject` to prevent ownership from changing until the current owner releases the lock. (#2863)
- Added distributed authority mode specific `NetworkObject.RequestOwnership` method that sends an ownership request to the current owner of a spawned `NetworkObject` instance. (#2863)
- Added distributed authority mode specific `NetworkObject.OnOwnershipRequested` callback handler that is invoked on the owner/authoritative side when a non-owner requests ownership. Depending upon the boolean returned value depends upon whether the request is approved or denied. (#2863)
- Added distributed authority mode specific `NetworkObject.OnOwnershipRequestResponse` callback handler that is invoked when a non-owner's request has been processed. This callback includes a `NetworkObjet.OwnershipRequestResponseStatus` response parameter that describes whether the request was approved or the reason why it was not approved. (#2863)
- Added distributed authority mode specific `NetworkObject.DeferDespawn` method that defers the despawning of `NetworkObject` instances on non-authoritative clients based on the tick offset parameter. (#2863)
- Added distributed authority mode specific `NetworkObject.OnDeferredDespawnComplete` callback handler that can be used to further control when deferring the despawning of a `NetworkObject` on non-authoritative instances. (#2863)
- Added `NetworkClient.SessionModeType` as one way to determine the current session mode of the network session a client is connected to. (#2863)
- Added distributed authority mode specific `NetworkClient.IsSessionOwner` property to determine if the current local client is the current session owner of a distributed authority session. (#2863)
- Added distributed authority mode specific client side spawning capabilities. When running in distributed authority mode, clients can instantiate and spawn `NetworkObject` instances (the local client is authomatically the owner of the spawned object). (#2863)
- This is useful to better visually synchronize owner authoritative motion models and newly spawned `NetworkObject` instances (i.e. projectiles for example).
- Added distributed authority mode specific client side player spawning capabilities. Clients will automatically spawn their associated player object locally. (#2863)
- Added distributed authority mode specific `NetworkConfig.AutoSpawnPlayerPrefabClientSide` property (default is true) to provide control over the automatic spawning of player prefabs on the local client side. (#2863)
- Added distributed authority mode specific `NetworkManager.OnFetchLocalPlayerPrefabToSpawn` callback that, when assigned, will allow the local client to provide the player prefab to be spawned for the local client. (#2863)
- This is only invoked if the `NetworkConfig.AutoSpawnPlayerPrefabClientSide` property is set to true.
- Added distributed authority mode specific `NetworkBehaviour.HasAuthority` property that determines if the local client has authority over the associated `NetworkObject` instance (typical use case is within a `NetworkBehaviour` script much like that of `IsServer` or `IsClient`). (#2863)
- Added distributed authority mode specific `NetworkBehaviour.IsSessionOwner` property that determines if the local client is the session owner (typical use case would be to determine if the local client can has scene management authority within a `NetworkBehaviour` script). (#2863)
- Added support for distributed authority mode scene management where the currently assigned session owner can start scene events (i.e. scene loading and scene unloading). (#2863)
### Fixed
- Fixed issue where the host was not invoking `OnClientDisconnectCallback` for its own local client when internally shutting down. (#2822)
- Fixed issue where NetworkTransform could potentially attempt to "unregister" a named message prior to it being registered. (#2807)
- Fixed issue where in-scene placed `NetworkObject`s with complex nested children `NetworkObject`s (more than one child in depth) would not synchronize properly if WorldPositionStays was set to true. (#2796)
### Changed
- Changed client side awareness of other clients is now the same as a server or host. (#2863)
- Changed `NetworkManager.ConnectedClients` can now be accessed by both server and clients. (#2863)
- Changed `NetworkManager.ConnectedClientsList` can now be accessed by both server and clients. (#2863)
- Changed `NetworkTransform` defaults to owner authoritative when connected to a distributed authority session. (#2863)
- Changed `NetworkVariable` defaults to owner write and everyone read permissions when connected to a distributed authority session (even if declared with server read or write permissions). (#2863)
- Changed `NetworkObject` no longer implements the `MonoBehaviour.Update` method in order to determine whether a `NetworkObject` instance has been migrated to a different scene. Instead, only `NetworkObjects` with the `SceneMigrationSynchronization` property set will be updated internally during the `NetworkUpdateStage.PostLateUpdate` by `NetworkManager`. (#2863)
- Changed `NetworkManager` inspector view layout where properties are now organized by category. (#2863)
- Changed `NetworkTransform` to now use `NetworkTransformMessage` as opposed to named messages for NetworkTransformState updates. (#2810)
- Changed `CustomMessageManager` so it no longer attempts to register or "unregister" a null or empty string and will log an error if this condition occurs. (#2807)
## [1.8.1] - 2024-02-05 ## [1.8.1] - 2024-02-05
### Fixed ### Fixed

8
Components/Messages.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: a9db1d18fa0117f4da5e8e65386b894a
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

205
Components/Messages/NetworkTransformMessage.cs Normal file
View File

@@ -0,0 +1,205 @@
using Unity.Netcode.Components;
using UnityEngine;
namespace Unity.Netcode
{
/// <summary>
/// NetworkTransform State Update Message
/// </summary>
internal struct NetworkTransformMessage : INetworkMessage
{
public int Version => 0;
public ulong NetworkObjectId;
public int NetworkBehaviourId;
// This is only used when serializing but not serialized
public bool DistributedAuthorityMode;
// Might get removed
public ulong[] TargetIds;
private int GetTargetIdLength()
{
if (TargetIds != null)
{
return TargetIds.Length;
}
return 0;
}
public NetworkTransform.NetworkTransformState State;
private NetworkTransform m_ReceiverNetworkTransform;
private FastBufferReader m_CurrentReader;
private unsafe void CopyPayload(ref FastBufferWriter writer)
{
writer.WriteBytesSafe(m_CurrentReader.GetUnsafePtrAtCurrentPosition(), m_CurrentReader.Length - m_CurrentReader.Position);
}
public void Serialize(FastBufferWriter writer, int targetVersion)
{
if (m_CurrentReader.IsInitialized)
{
CopyPayload(ref writer);
}
else
{
BytePacker.WriteValueBitPacked(writer, NetworkObjectId);
BytePacker.WriteValueBitPacked(writer, NetworkBehaviourId);
writer.WriteNetworkSerializable(State);
if (DistributedAuthorityMode)
{
var length = GetTargetIdLength();
BytePacker.WriteValuePacked(writer, length);
// If no target ids, then just exit early (DAHost specific)
if (length == 0)
{
return;
}
foreach (var target in TargetIds)
{
BytePacker.WriteValuePacked(writer, target);
}
}
}
}
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
var networkManager = context.SystemOwner as NetworkManager;
if (networkManager == null)
{
Debug.LogError($"[{nameof(NetworkTransformMessage)}] System owner context was not of type {nameof(NetworkManager)}!");
return false;
}
var currentPosition = reader.Position;
ByteUnpacker.ReadValueBitPacked(reader, out NetworkObjectId);
var isSpawnedLocally = networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId);
// Only defer if the NetworkObject is not spawned yet and the local NetworkManager is not running as a DAHost.
if (!isSpawnedLocally && !networkManager.DAHost)
{
networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
return false;
}
// While the below check and assignment might seem out of place, this is specific to running in DAHost mode when a NetworkObject is
// hidden from the DAHost but is visible to other clients. Since the DAHost needs to forward updates to the clients, we ignore processing
// this message locally
var networkObject = (NetworkObject)null;
var isServerAuthoritative = false;
var ownerAuthoritativeServerSide = false;
// Get the behaviour index
ByteUnpacker.ReadValueBitPacked(reader, out NetworkBehaviourId);
// Deserialize the state
reader.ReadNetworkSerializableInPlace(ref State);
if (networkManager.DistributedAuthorityMode)
{
var targetCount = 0;
ByteUnpacker.ReadValueBitPacked(reader, out targetCount);
if (targetCount > 0)
{
TargetIds = new ulong[targetCount];
}
var targetId = (ulong)0;
for (int i = 0; i < targetCount; i++)
{
ByteUnpacker.ReadValueBitPacked(reader, out targetId);
TargetIds[i] = targetId;
}
}
if (isSpawnedLocally)
{
networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
// Get the target NetworkTransform
m_ReceiverNetworkTransform = networkObject.ChildNetworkBehaviours[NetworkBehaviourId] as NetworkTransform;
isServerAuthoritative = m_ReceiverNetworkTransform.IsServerAuthoritative();
ownerAuthoritativeServerSide = !isServerAuthoritative && networkManager.IsServer;
}
else
{
// If we are the DAHost and the NetworkObject is hidden from the host we still need to forward this message
ownerAuthoritativeServerSide = networkManager.DAHost && !isSpawnedLocally;
}
if (ownerAuthoritativeServerSide)
{
var ownerClientId = (ulong)0;
if (networkObject != null)
{
ownerClientId = networkObject.OwnerClientId;
if (ownerClientId == NetworkManager.ServerClientId)
{
// Ownership must have changed, ignore any additional pending messages that might have
// come from a previous owner client.
return true;
}
}
else if (networkManager.DAHost)
{
// Specific to distributed authority mode, the only sender of state updates will be the owner
ownerClientId = context.SenderId;
}
var networkDelivery = State.IsReliableStateUpdate() ? NetworkDelivery.ReliableSequenced : NetworkDelivery.UnreliableSequenced;
// Forward the state update if there are any remote clients to foward it to
if (networkManager.ConnectionManager.ConnectedClientsList.Count > (networkManager.IsHost ? 2 : 1))
{
var clientCount = networkManager.DistributedAuthorityMode ? GetTargetIdLength() : networkManager.ConnectionManager.ConnectedClientsList.Count;
if (clientCount == 0)
{
return true;
}
// This is only to copy the existing and already serialized struct for forwarding purposes only.
// This will not include any changes made to this struct at this particular stage of processing the message.
var currentMessage = this;
// Create a new reader that replicates this message
currentMessage.m_CurrentReader = new FastBufferReader(reader, Collections.Allocator.None);
// Rewind the new reader to the beginning of the message's payload
currentMessage.m_CurrentReader.Seek(currentPosition);
// Forward the message to all connected clients that are observers of the associated NetworkObject
for (int i = 0; i < clientCount; i++)
{
var clientId = networkManager.DistributedAuthorityMode ? TargetIds[i] : networkManager.ConnectionManager.ConnectedClientsList[i].ClientId;
if (NetworkManager.ServerClientId == clientId || (!isServerAuthoritative && clientId == ownerClientId) ||
(!networkManager.DistributedAuthorityMode && !networkObject.Observers.Contains(clientId)))
{
continue;
}
networkManager.MessageManager.SendMessage(ref currentMessage, networkDelivery, clientId);
}
// Dispose of the reader used for forwarding
currentMessage.m_CurrentReader.Dispose();
}
}
return true;
}
public void Handle(ref NetworkContext context)
{
var networkManager = context.SystemOwner as NetworkManager;
// Only if the local NetworkManager instance is running as the DAHost we just exit if there is no local
// NetworkTransform component to apply the state update to (i.e. it is hidden from the DAHost and it
// just forwarded the state update to any other connected client)
if (networkManager.DAHost && m_ReceiverNetworkTransform == null)
{
return;
}
if (m_ReceiverNetworkTransform == null)
{
Debug.LogError($"[{nameof(NetworkTransformMessage)}][Dropped] Reciever {nameof(NetworkTransform)} was not set!");
return;
}
m_ReceiverNetworkTransform.TransformStateUpdate(ref State, context.SenderId);
}
}
}

11
Components/Messages/NetworkTransformMessage.cs.meta Normal file
View File

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

154
Components/NetworkAnimator.cs
View File

@@ -25,26 +25,48 @@ namespace Unity.Netcode.Components
{ {
foreach (var animationUpdate in m_SendAnimationUpdates) foreach (var animationUpdate in m_SendAnimationUpdates)
{ {
m_NetworkAnimator.SendAnimStateClientRpc(animationUpdate.AnimationMessage, animationUpdate.ClientRpcParams);
if (m_NetworkAnimator.NetworkManager.DistributedAuthorityMode)
{
m_NetworkAnimator.SendAnimStateRpc(animationUpdate.AnimationMessage);
}
else
{
m_NetworkAnimator.SendAnimStateClientRpc(animationUpdate.AnimationMessage, animationUpdate.ClientRpcParams);
}
} }
m_SendAnimationUpdates.Clear(); m_SendAnimationUpdates.Clear();
foreach (var sendEntry in m_SendParameterUpdates) foreach (var sendEntry in m_SendParameterUpdates)
{ {
m_NetworkAnimator.SendParametersUpdateClientRpc(sendEntry.ParametersUpdateMessage, sendEntry.ClientRpcParams); if (m_NetworkAnimator.NetworkManager.DistributedAuthorityMode)
{
m_NetworkAnimator.SendParametersUpdateRpc(sendEntry.ParametersUpdateMessage);
}
else
{
m_NetworkAnimator.SendParametersUpdateClientRpc(sendEntry.ParametersUpdateMessage, sendEntry.ClientRpcParams);
}
} }
m_SendParameterUpdates.Clear(); m_SendParameterUpdates.Clear();
foreach (var sendEntry in m_SendTriggerUpdates) foreach (var sendEntry in m_SendTriggerUpdates)
{ {
if (!sendEntry.SendToServer) if (m_NetworkAnimator.NetworkManager.DistributedAuthorityMode)
{ {
m_NetworkAnimator.SendAnimTriggerClientRpc(sendEntry.AnimationTriggerMessage, sendEntry.ClientRpcParams); m_NetworkAnimator.SendAnimTriggerRpc(sendEntry.AnimationTriggerMessage);
} }
else else
{ {
m_NetworkAnimator.SendAnimTriggerServerRpc(sendEntry.AnimationTriggerMessage); if (!sendEntry.SendToServer)
{
m_NetworkAnimator.SendAnimTriggerClientRpc(sendEntry.AnimationTriggerMessage, sendEntry.ClientRpcParams);
}
else
{
m_NetworkAnimator.SendAnimTriggerServerRpc(sendEntry.AnimationTriggerMessage);
}
} }
} }
m_SendTriggerUpdates.Clear(); m_SendTriggerUpdates.Clear();
@@ -652,17 +674,14 @@ namespace Unity.Netcode.Components
NetworkLog.LogWarningServer($"[{gameObject.name}][{nameof(NetworkAnimator)}] {nameof(Animator)} is not assigned! Animation synchronization will not work for this instance!"); NetworkLog.LogWarningServer($"[{gameObject.name}][{nameof(NetworkAnimator)}] {nameof(Animator)} is not assigned! Animation synchronization will not work for this instance!");
} }
if (IsServer) m_ClientSendList = new List<ulong>(128);
m_ClientRpcParams = new ClientRpcParams
{ {
m_ClientSendList = new List<ulong>(128); Send = new ClientRpcSendParams
m_ClientRpcParams = new ClientRpcParams
{ {
Send = new ClientRpcSendParams TargetClientIds = m_ClientSendList
{ }
TargetClientIds = m_ClientSendList };
}
};
}
// Create a handler for state changes // Create a handler for state changes
m_NetworkAnimatorStateChangeHandler = new NetworkAnimatorStateChangeHandler(this); m_NetworkAnimatorStateChangeHandler = new NetworkAnimatorStateChangeHandler(this);
@@ -908,6 +927,11 @@ namespace Unity.Netcode.Components
// Send an AnimationMessage only if there are dirty AnimationStates to send // Send an AnimationMessage only if there are dirty AnimationStates to send
if (m_AnimationMessage.IsDirtyCount > 0) if (m_AnimationMessage.IsDirtyCount > 0)
{ {
if (NetworkManager.DistributedAuthorityMode)
{
SendAnimStateRpc(m_AnimationMessage);
}
else
if (!IsServer && IsOwner) if (!IsServer && IsOwner)
{ {
SendAnimStateServerRpc(m_AnimationMessage); SendAnimStateServerRpc(m_AnimationMessage);
@@ -932,20 +956,33 @@ namespace Unity.Netcode.Components
{ {
Parameters = m_ParameterWriter.ToArray() Parameters = m_ParameterWriter.ToArray()
}; };
if (NetworkManager.DistributedAuthorityMode)
if (!IsServer)
{ {
SendParametersUpdateServerRpc(parametersMessage); if (IsOwner)
}
else
{
if (sendDirect)
{ {
SendParametersUpdateClientRpc(parametersMessage, clientRpcParams); SendParametersUpdateRpc(parametersMessage);
} }
else else
{ {
m_NetworkAnimatorStateChangeHandler.SendParameterUpdate(parametersMessage, clientRpcParams); Debug.LogError($"[{name}][Client-{NetworkManager.LocalClientId}] Attempting to send parameter updates but not the owner!");
}
}
else
{
if (!IsServer)
{
SendParametersUpdateServerRpc(parametersMessage);
}
else
{
if (sendDirect)
{
SendParametersUpdateClientRpc(parametersMessage, clientRpcParams);
}
else
{
m_NetworkAnimatorStateChangeHandler.SendParameterUpdate(parametersMessage, clientRpcParams);
}
} }
} }
} }
@@ -1225,10 +1262,19 @@ namespace Unity.Netcode.Components
} }
/// <summary> /// <summary>
/// Updates the client's animator's parameters /// Distributed Authority: Updates the client's animator's parameters
/// </summary>
[Rpc(SendTo.NotAuthority)]
internal void SendParametersUpdateRpc(ParametersUpdateMessage parametersUpdate)
{
m_NetworkAnimatorStateChangeHandler.ProcessParameterUpdate(parametersUpdate);
}
/// <summary>
/// Client-Server: Updates the client's animator's parameters
/// </summary> /// </summary>
[ClientRpc] [ClientRpc]
internal unsafe void SendParametersUpdateClientRpc(ParametersUpdateMessage parametersUpdate, ClientRpcParams clientRpcParams = default) internal void SendParametersUpdateClientRpc(ParametersUpdateMessage parametersUpdate, ClientRpcParams clientRpcParams = default)
{ {
var isServerAuthoritative = IsServerAuthoritative(); var isServerAuthoritative = IsServerAuthoritative();
if (!isServerAuthoritative && !IsOwner || isServerAuthoritative) if (!isServerAuthoritative && !IsOwner || isServerAuthoritative)
@@ -1242,7 +1288,7 @@ namespace Unity.Netcode.Components
/// The server sets its local state and then forwards the message to the remaining clients /// The server sets its local state and then forwards the message to the remaining clients
/// </summary> /// </summary>
[ServerRpc] [ServerRpc]
private unsafe void SendAnimStateServerRpc(AnimationMessage animationMessage, ServerRpcParams serverRpcParams = default) private void SendAnimStateServerRpc(AnimationMessage animationMessage, ServerRpcParams serverRpcParams = default)
{ {
if (IsServerAuthoritative()) if (IsServerAuthoritative())
{ {
@@ -1273,26 +1319,44 @@ namespace Unity.Netcode.Components
} }
/// <summary> /// <summary>
/// Internally-called RPC client receiving function to update some animation state on a client /// Client-Server: Internally-called RPC client-side receiving function to update animation states
/// </summary> /// </summary>
[ClientRpc] [ClientRpc]
internal unsafe void SendAnimStateClientRpc(AnimationMessage animationMessage, ClientRpcParams clientRpcParams = default) internal void SendAnimStateClientRpc(AnimationMessage animationMessage, ClientRpcParams clientRpcParams = default)
{ {
// This should never happen ProcessAnimStates(animationMessage);
if (IsHost) }
/// <summary>
/// Distributed Authority: Internally-called RPC non-authority receiving function to update animation states
/// </summary>
[Rpc(SendTo.NotAuthority)]
internal void SendAnimStateRpc(AnimationMessage animationMessage)
{
ProcessAnimStates(animationMessage);
}
private void ProcessAnimStates(AnimationMessage animationMessage)
{
if (HasAuthority)
{ {
if (NetworkManager.LogLevel == LogLevel.Developer) if (NetworkManager.LogLevel == LogLevel.Developer)
{ {
NetworkLog.LogWarning("Detected the Host is sending itself animation updates! Please report this issue."); var hostOrOwner = NetworkManager.DistributedAuthorityMode ? "Owner" : "Host";
var clientServerOrDAMode = NetworkManager.DistributedAuthorityMode ? "distributed authority" : "client-server";
NetworkLog.LogWarning($"Detected the {hostOrOwner} is sending itself animation updates in {clientServerOrDAMode} mode! Please report this issue.");
} }
return; return;
} }
foreach (var animationState in animationMessage.AnimationStates) foreach (var animationState in animationMessage.AnimationStates)
{ {
UpdateAnimationState(animationState); UpdateAnimationState(animationState);
} }
} }
/// <summary> /// <summary>
/// Server-side trigger state update request /// Server-side trigger state update request
/// The server sets its local state and then forwards the message to the remaining clients /// The server sets its local state and then forwards the message to the remaining clients
@@ -1337,7 +1401,18 @@ namespace Unity.Netcode.Components
} }
/// <summary> /// <summary>
/// Internally-called RPC client receiving function to update a trigger when the server wants to forward /// Distributed Authority: Internally-called RPC client receiving function to update a trigger when the server wants to forward
/// a trigger for a client to play / reset
/// </summary>
/// <param name="animationTriggerMessage">the payload containing the trigger data to apply</param>
[Rpc(SendTo.NotAuthority)]
internal void SendAnimTriggerRpc(AnimationTriggerMessage animationTriggerMessage)
{
InternalSetTrigger(animationTriggerMessage.Hash, animationTriggerMessage.IsTriggerSet);
}
/// <summary>
/// Client Server: Internally-called RPC client receiving function to update a trigger when the server wants to forward
/// a trigger for a client to play / reset /// a trigger for a client to play / reset
/// </summary> /// </summary>
/// <param name="animationTriggerMessage">the payload containing the trigger data to apply</param> /// <param name="animationTriggerMessage">the payload containing the trigger data to apply</param>
@@ -1362,15 +1437,26 @@ namespace Unity.Netcode.Components
/// <param name="setTrigger">sets (true) or resets (false) the trigger. The default is to set it (true).</param> /// <param name="setTrigger">sets (true) or resets (false) the trigger. The default is to set it (true).</param>
public void SetTrigger(int hash, bool setTrigger = true) public void SetTrigger(int hash, bool setTrigger = true)
{ {
if (!IsSpawned)
{
NetworkLog.LogError($"[{gameObject.name}] Cannot set a synchronized trigger when the {nameof(NetworkObject)} is not spawned!");
return;
}
// MTT-3564: // MTT-3564:
// After fixing the issue with trigger controlled Transitions being synchronized twice, // After fixing the issue with trigger controlled Transitions being synchronized twice,
// it exposed additional issues with this logic. Now, either the owner or the server can // it exposed additional issues with this logic. Now, either the owner or the server can
// update triggers. Since server-side RPCs are immediately invoked, for a host a trigger // update triggers. Since server-side RPCs are immediately invoked, for a host a trigger
// will happen when SendAnimTriggerClientRpc is called. For a client owner, we call the // will happen when SendAnimTriggerClientRpc is called. For a client owner, we call the
// SendAnimTriggerServerRpc and then trigger locally when running in owner authority mode. // SendAnimTriggerServerRpc and then trigger locally when running in owner authority mode.
if (IsOwner || IsServer) var animTriggerMessage = new AnimationTriggerMessage() { Hash = hash, IsTriggerSet = setTrigger };
if (NetworkManager.DistributedAuthorityMode && HasAuthority)
{
m_NetworkAnimatorStateChangeHandler.QueueTriggerUpdateToClient(animTriggerMessage);
InternalSetTrigger(hash, setTrigger);
}
else if (!NetworkManager.DistributedAuthorityMode && (IsOwner || IsServer))
{ {
var animTriggerMessage = new AnimationTriggerMessage() { Hash = hash, IsTriggerSet = setTrigger };
if (IsServer) if (IsServer)
{ {
/// <see cref="UpdatePendingTriggerStates"/> as to why we queue /// <see cref="UpdatePendingTriggerStates"/> as to why we queue

535
Components/NetworkRigidBodyBase.cs Normal file
View File

@@ -0,0 +1,535 @@
#if COM_UNITY_MODULES_PHYSICS
using System.Runtime.CompilerServices;
using UnityEngine;
namespace Unity.Netcode.Components
{
/// <summary>
/// NetworkRigidbodyBase is a unified <see cref="Rigidbody"/> and <see cref="Rigidbody2D"/> integration that helps to synchronize physics motion, collision, and interpolation
/// when used with a <see cref="NetworkTransform"/>.
/// </summary>
/// <remarks>
/// For a customizable netcode Rigidbody, create your own component from this class and use <see cref="Initialize(RigidbodyTypes, NetworkTransform, Rigidbody2D, Rigidbody)"/>
/// during instantiation (i.e. invoked from within the Awake method). You can re-initialize after having initialized but only when the <see cref="NetworkObject"/> is not spawned.
/// </remarks>
public abstract class NetworkRigidbodyBase : NetworkBehaviour
{
/// <summary>
/// When enabled, the associated <see cref="NetworkTransform"/> will use the Rigidbody/Rigidbody2D to apply and synchronize changes in position, rotation, and
/// allows for the use of Rigidbody interpolation/extrapolation.
/// </summary>
/// <remarks>
/// If <see cref="NetworkTransform.Interpolate"/> is enabled, non-authoritative instances can only use Rigidbody interpolation. If a network prefab is set to
/// extrapolation and <see cref="NetworkTransform.Interpolate"/> is enabled, then non-authoritative instances will automatically be adjusted to use Rigidbody
/// interpolation while the authoritative instance will still use extrapolation.
/// </remarks>
public bool UseRigidBodyForMotion;
/// <summary>
/// When enabled (default), automatically set the Kinematic state of the Rigidbody based on ownership.
/// When disabled, Kinematic state needs to be set by external script(s).
/// </summary>
public bool AutoUpdateKinematicState = true;
/// <summary>
/// Primarily applies to the <see cref="AutoUpdateKinematicState"/> property when disabled but you still want
/// the Rigidbody to be automatically set to Kinematic when despawned.
/// </summary>
public bool AutoSetKinematicOnDespawn = true;
// Determines if this is a Rigidbody or Rigidbody2D implementation
private bool m_IsRigidbody2D => RigidbodyType == RigidbodyTypes.Rigidbody2D;
// Used to cache the authority state of this Rigidbody during the last frame
private bool m_IsAuthority;
private Rigidbody m_Rigidbody;
private Rigidbody2D m_Rigidbody2D;
private NetworkTransform m_NetworkTransform;
private enum InterpolationTypes
{
None,
Interpolate,
Extrapolate
}
private InterpolationTypes m_OriginalInterpolation;
/// <summary>
/// Used to define the type of Rigidbody implemented.
/// <see cref=""/>
/// </summary>
public enum RigidbodyTypes
{
Rigidbody,
Rigidbody2D,
}
public RigidbodyTypes RigidbodyType { get; private set; }
/// <summary>
/// Initializes the networked Rigidbody based on the <see cref="RigidbodyTypes"/>
/// passed in as a parameter.
/// </summary>
/// <remarks>
/// Cannot be initialized while the associated <see cref="NetworkObject"/> is spawned.
/// </remarks>
/// <param name="rigidbodyType">type of rigid body being initialized</param>
/// <param name="rigidbody2D">(optional) The <see cref="Rigidbody2D"/> to be used</param>
/// <param name="rigidbody">(optional) The <see cref="Rigidbody"/> to be used</param>
protected void Initialize(RigidbodyTypes rigidbodyType, NetworkTransform networkTransform = null, Rigidbody2D rigidbody2D = null, Rigidbody rigidbody = null)
{
// Don't initialize if already spawned
if (IsSpawned)
{
Debug.LogError($"[{name}] Attempting to initialize while spawned is not allowed.");
return;
}
RigidbodyType = rigidbodyType;
m_Rigidbody2D = rigidbody2D;
m_Rigidbody = rigidbody;
m_NetworkTransform = networkTransform;
if (m_IsRigidbody2D && m_Rigidbody2D == null)
{
m_Rigidbody2D = GetComponent<Rigidbody2D>();
}
else if (m_Rigidbody == null)
{
m_Rigidbody = GetComponent<Rigidbody>();
}
SetOriginalInterpolation();
if (m_NetworkTransform == null)
{
m_NetworkTransform = GetComponent<NetworkTransform>();
}
if (m_NetworkTransform != null)
{
m_NetworkTransform.RegisterRigidbody(this);
}
else
{
throw new System.Exception($"[Missing {nameof(NetworkTransform)}] No {nameof(NetworkTransform)} is assigned or can be found during initialization!");
}
if (AutoUpdateKinematicState)
{
SetIsKinematic(true);
}
}
/// <summary>
/// Gets the position of the Rigidbody
/// </summary>
/// <returns><see cref="Vector3"/></returns>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Vector3 GetPosition()
{
if (m_IsRigidbody2D)
{
return m_Rigidbody2D.position;
}
else
{
return m_Rigidbody.position;
}
}
/// <summary>
/// Gets the rotation of the Rigidbody
/// </summary>
/// <returns><see cref="Quaternion"/></returns>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Quaternion GetRotation()
{
if (m_IsRigidbody2D)
{
var quaternion = Quaternion.identity;
var angles = quaternion.eulerAngles;
angles.z = m_Rigidbody2D.rotation;
quaternion.eulerAngles = angles;
return quaternion;
}
else
{
return m_Rigidbody.rotation;
}
}
/// <summary>
/// Moves the rigid body
/// </summary>
/// <param name="position">The <see cref="Vector3"/> position to move towards</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void MovePosition(Vector3 position)
{
if (m_IsRigidbody2D)
{
m_Rigidbody2D.MovePosition(position);
}
else
{
m_Rigidbody.MovePosition(position);
}
}
/// <summary>
/// Directly applies a position (like teleporting)
/// </summary>
/// <param name="position"><see cref="Vector3"/> position to apply to the Rigidbody</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void SetPosition(Vector3 position)
{
if (m_IsRigidbody2D)
{
m_Rigidbody2D.position = position;
}
else
{
m_Rigidbody.position = position;
}
}
/// <summary>
/// Applies the rotation and position of the <see cref="GameObject"/>'s <see cref="Transform"/>
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void ApplyCurrentTransform()
{
if (m_IsRigidbody2D)
{
m_Rigidbody2D.position = transform.position;
m_Rigidbody2D.rotation = transform.eulerAngles.z;
}
else
{
m_Rigidbody.position = transform.position;
m_Rigidbody.rotation = transform.rotation;
}
}
/// <summary>
/// Rotatates the Rigidbody towards a specified rotation
/// </summary>
/// <param name="rotation">The rotation expressed as a <see cref="Quaternion"/></param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void MoveRotation(Quaternion rotation)
{
if (m_IsRigidbody2D)
{
m_Rigidbody2D.MoveRotation(rotation);
}
else
{
m_Rigidbody.MoveRotation(rotation);
}
}
/// <summary>
/// Applies a rotation to the Rigidbody
/// </summary>
/// <param name="rotation">The rotation to apply expressed as a <see cref="Quaternion"/></param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void SetRotation(Quaternion rotation)
{
if (m_IsRigidbody2D)
{
m_Rigidbody2D.rotation = rotation.eulerAngles.z;
}
else
{
m_Rigidbody.rotation = rotation;
}
}
/// <summary>
/// Sets the original interpolation of the Rigidbody while taking the Rigidbody type into consideration
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void SetOriginalInterpolation()
{
if (m_IsRigidbody2D)
{
switch (m_Rigidbody2D.interpolation)
{
case RigidbodyInterpolation2D.None:
{
m_OriginalInterpolation = InterpolationTypes.None;
break;
}
case RigidbodyInterpolation2D.Interpolate:
{
m_OriginalInterpolation = InterpolationTypes.Interpolate;
break;
}
case RigidbodyInterpolation2D.Extrapolate:
{
m_OriginalInterpolation = InterpolationTypes.Extrapolate;
break;
}
}
}
else
{
switch (m_Rigidbody.interpolation)
{
case RigidbodyInterpolation.None:
{
m_OriginalInterpolation = InterpolationTypes.None;
break;
}
case RigidbodyInterpolation.Interpolate:
{
m_OriginalInterpolation = InterpolationTypes.Interpolate;
break;
}
case RigidbodyInterpolation.Extrapolate:
{
m_OriginalInterpolation = InterpolationTypes.Extrapolate;
break;
}
}
}
}
/// <summary>
/// Wakes the Rigidbody if it is sleeping
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void WakeIfSleeping()
{
if (m_IsRigidbody2D)
{
if (m_Rigidbody2D.IsSleeping())
{
m_Rigidbody2D.WakeUp();
}
}
else
{
if (m_Rigidbody.IsSleeping())
{
m_Rigidbody.WakeUp();
}
}
}
/// <summary>
/// Puts the Rigidbody to sleep
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void SleepRigidbody()
{
if (m_IsRigidbody2D)
{
m_Rigidbody2D.Sleep();
}
else
{
m_Rigidbody.Sleep();
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool IsKinematic()
{
if (m_IsRigidbody2D)
{
return m_Rigidbody2D.isKinematic;
}
else
{
return m_Rigidbody.isKinematic;
}
}
/// <summary>
/// Sets the kinematic state of the Rigidbody and handles updating the Rigidbody's
/// interpolation setting based on the Kinematic state.
/// </summary>
/// <remarks>
/// When using the Rigidbody for <see cref="NetworkTransform"/> motion, this automatically
/// adjusts from extrapolation to interpolation if:
/// - The Rigidbody was originally set to extrapolation
/// - The NetworkTransform is set to interpolate
/// When the two above conditions are true:
/// - When switching from non-kinematic to kinematic this will automatically
/// switch the Rigidbody from extrapolation to interpolate.
/// - When switching from kinematic to non-kinematic this will automatically
/// switch the Rigidbody from interpolation back to extrapolation.
/// </remarks>
/// <param name="isKinematic"></param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void SetIsKinematic(bool isKinematic)
{
if (m_IsRigidbody2D)
{
m_Rigidbody2D.isKinematic = isKinematic;
}
else
{
m_Rigidbody.isKinematic = isKinematic;
}
// If we are not spawned, then exit early
if (!IsSpawned)
{
return;
}
if (UseRigidBodyForMotion)
{
// Only if the NetworkTransform is set to interpolate do we need to check for extrapolation
if (m_NetworkTransform.Interpolate && m_OriginalInterpolation == InterpolationTypes.Extrapolate)
{
if (IsKinematic())
{
// If not already set to interpolate then set the Rigidbody to interpolate
if (m_Rigidbody.interpolation == RigidbodyInterpolation.Extrapolate)
{
// Sleep until the next fixed update when switching from extrapolation to interpolation
SleepRigidbody();
SetInterpolation(InterpolationTypes.Interpolate);
}
}
else
{
// Switch it back to the original interpolation if non-kinematic (doesn't require sleep).
SetInterpolation(m_OriginalInterpolation);
}
}
}
else
{
SetInterpolation(m_IsAuthority ? m_OriginalInterpolation : (m_NetworkTransform.Interpolate ? InterpolationTypes.None : m_OriginalInterpolation));
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void SetInterpolation(InterpolationTypes interpolationType)
{
switch (interpolationType)
{
case InterpolationTypes.None:
{
if (m_IsRigidbody2D)
{
m_Rigidbody2D.interpolation = RigidbodyInterpolation2D.None;
}
else
{
m_Rigidbody.interpolation = RigidbodyInterpolation.None;
}
break;
}
case InterpolationTypes.Interpolate:
{
if (m_IsRigidbody2D)
{
m_Rigidbody2D.interpolation = RigidbodyInterpolation2D.Interpolate;
}
else
{
m_Rigidbody.interpolation = RigidbodyInterpolation.Interpolate;
}
break;
}
case InterpolationTypes.Extrapolate:
{
if (m_IsRigidbody2D)
{
m_Rigidbody2D.interpolation = RigidbodyInterpolation2D.Extrapolate;
}
else
{
m_Rigidbody.interpolation = RigidbodyInterpolation.Extrapolate;
}
break;
}
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void ResetInterpolation()
{
SetInterpolation(m_OriginalInterpolation);
}
protected override void OnOwnershipChanged(ulong previous, ulong current)
{
UpdateOwnershipAuthority();
base.OnOwnershipChanged(previous, current);
}
/// <summary>
/// Sets the authority based on whether it is server or owner authoritative
/// </summary>
/// <remarks>
/// Distributed authority sessions will always be owner authoritative.
/// </remarks>
internal void UpdateOwnershipAuthority()
{
if (NetworkManager.DistributedAuthorityMode)
{
// When in distributed authority mode, always use HasAuthority
m_IsAuthority = HasAuthority;
}
else
{
if (m_NetworkTransform.IsServerAuthoritative())
{
m_IsAuthority = NetworkManager.IsServer;
}
else
{
m_IsAuthority = IsOwner;
}
}
if (AutoUpdateKinematicState)
{
SetIsKinematic(!m_IsAuthority);
}
}
/// <inheritdoc />
public override void OnNetworkSpawn()
{
UpdateOwnershipAuthority();
}
/// <inheritdoc />
public override void OnNetworkDespawn()
{
// If we are automatically handling the kinematic state...
if (AutoUpdateKinematicState || AutoSetKinematicOnDespawn)
{
// Turn off physics for the rigid body until spawned, otherwise
// non-owners can run fixed updates before the first full
// NetworkTransform update and physics will be applied (i.e. gravity, etc)
SetIsKinematic(true);
}
SetInterpolation(m_OriginalInterpolation);
}
/// <summary>
/// When <see cref="UseRigidBodyForMotion"/> is enabled, the <see cref="NetworkTransform"/> will update Kinematic instances using
/// the Rigidbody's move methods allowing Rigidbody interpolation settings to be taken into consideration by the physics simulation.
/// </summary>
/// <remarks>
/// This will update the associated <see cref="NetworkTransform"/> during FixedUpdate which also avoids the added expense of adding
/// a FixedUpdate to all <see cref="NetworkTransform"/> instances where some might not be using a Rigidbody.
/// </remarks>
private void FixedUpdate()
{
if (!IsSpawned || m_NetworkTransform == null || !UseRigidBodyForMotion)
{
return;
}
m_NetworkTransform.OnFixedUpdate();
}
}
}
#endif // COM_UNITY_MODULES_PHYSICS

11
Components/NetworkRigidBodyBase.cs.meta Normal file
View File

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

90
Components/NetworkRigidbody.cs
View File

@@ -7,96 +7,14 @@ namespace Unity.Netcode.Components
/// NetworkRigidbody allows for the use of <see cref="Rigidbody"/> on network objects. By controlling the kinematic /// NetworkRigidbody allows for the use of <see cref="Rigidbody"/> on network objects. By controlling the kinematic
/// mode of the <see cref="Rigidbody"/> and disabling it on all peers but the authoritative one. /// mode of the <see cref="Rigidbody"/> and disabling it on all peers but the authoritative one.
/// </summary> /// </summary>
[RequireComponent(typeof(Rigidbody))]
[RequireComponent(typeof(NetworkTransform))] [RequireComponent(typeof(NetworkTransform))]
[RequireComponent(typeof(Rigidbody))]
[AddComponentMenu("Netcode/Network Rigidbody")] [AddComponentMenu("Netcode/Network Rigidbody")]
public class NetworkRigidbody : NetworkBehaviour public class NetworkRigidbody : NetworkRigidbodyBase
{ {
/// <summary> protected virtual void Awake()
/// Determines if we are server (true) or owner (false) authoritative
/// </summary>
private bool m_IsServerAuthoritative;
private Rigidbody m_Rigidbody;
private NetworkTransform m_NetworkTransform;
private RigidbodyInterpolation m_OriginalInterpolation;
// Used to cache the authority state of this Rigidbody during the last frame
private bool m_IsAuthority;
private void Awake()
{ {
m_NetworkTransform = GetComponent<NetworkTransform>(); Initialize(RigidbodyTypes.Rigidbody);
m_IsServerAuthoritative = m_NetworkTransform.IsServerAuthoritative();
m_Rigidbody = GetComponent<Rigidbody>();
m_OriginalInterpolation = m_Rigidbody.interpolation;
// Set interpolation to none if NetworkTransform is handling interpolation, otherwise it sets it to the original value
m_Rigidbody.interpolation = m_NetworkTransform.Interpolate ? RigidbodyInterpolation.None : m_OriginalInterpolation;
// Turn off physics for the rigid body until spawned, otherwise
// clients can run fixed update before the first full
// NetworkTransform update
m_Rigidbody.isKinematic = true;
}
/// <summary>
/// For owner authoritative (i.e. ClientNetworkTransform)
/// we adjust our authority when we gain ownership
/// </summary>
public override void OnGainedOwnership()
{
UpdateOwnershipAuthority();
}
/// <summary>
/// For owner authoritative(i.e. ClientNetworkTransform)
/// we adjust our authority when we have lost ownership
/// </summary>
public override void OnLostOwnership()
{
UpdateOwnershipAuthority();
}
/// <summary>
/// Sets the authority differently depending upon
/// whether it is server or owner authoritative
/// </summary>
private void UpdateOwnershipAuthority()
{
if (m_IsServerAuthoritative)
{
m_IsAuthority = NetworkManager.IsServer;
}
else
{
m_IsAuthority = IsOwner;
}
// If you have authority then you are not kinematic
m_Rigidbody.isKinematic = !m_IsAuthority;
// Set interpolation of the Rigidbody based on authority
// With authority: let local transform handle interpolation
// Without authority: let the NetworkTransform handle interpolation
m_Rigidbody.interpolation = m_IsAuthority ? m_OriginalInterpolation : RigidbodyInterpolation.None;
}
/// <inheritdoc />
public override void OnNetworkSpawn()
{
UpdateOwnershipAuthority();
}
/// <inheritdoc />
public override void OnNetworkDespawn()
{
m_Rigidbody.interpolation = m_OriginalInterpolation;
// Turn off physics for the rigid body until spawned, otherwise
// non-owners can run fixed updates before the first full
// NetworkTransform update and physics will be applied (i.e. gravity, etc)
m_Rigidbody.isKinematic = true;
} }
} }
} }

70
Components/NetworkRigidbody2D.cs
View File

@@ -7,76 +7,14 @@ namespace Unity.Netcode.Components
/// NetworkRigidbody allows for the use of <see cref="Rigidbody2D"/> on network objects. By controlling the kinematic /// NetworkRigidbody allows for the use of <see cref="Rigidbody2D"/> on network objects. By controlling the kinematic
/// mode of the rigidbody and disabling it on all peers but the authoritative one. /// mode of the rigidbody and disabling it on all peers but the authoritative one.
/// </summary> /// </summary>
[RequireComponent(typeof(Rigidbody2D))]
[RequireComponent(typeof(NetworkTransform))] [RequireComponent(typeof(NetworkTransform))]
[RequireComponent(typeof(Rigidbody2D))]
[AddComponentMenu("Netcode/Network Rigidbody 2D")] [AddComponentMenu("Netcode/Network Rigidbody 2D")]
public class NetworkRigidbody2D : NetworkBehaviour public class NetworkRigidbody2D : NetworkRigidbodyBase
{ {
private Rigidbody2D m_Rigidbody; protected virtual void Awake()
private NetworkTransform m_NetworkTransform;
private bool m_OriginalKinematic;
private RigidbodyInterpolation2D m_OriginalInterpolation;
// Used to cache the authority state of this rigidbody during the last frame
private bool m_IsAuthority;
/// <summary>
/// Gets a bool value indicating whether this <see cref="NetworkRigidbody2D"/> on this peer currently holds authority.
/// </summary>
private bool HasAuthority => m_NetworkTransform.CanCommitToTransform;
private void Awake()
{ {
m_Rigidbody = GetComponent<Rigidbody2D>(); Initialize(RigidbodyTypes.Rigidbody2D);
m_NetworkTransform = GetComponent<NetworkTransform>();
}
private void FixedUpdate()
{
if (IsSpawned)
{
if (HasAuthority != m_IsAuthority)
{
m_IsAuthority = HasAuthority;
UpdateRigidbodyKinematicMode();
}
}
}
// Puts the rigidbody in a kinematic non-interpolated mode on everyone but the server.
private void UpdateRigidbodyKinematicMode()
{
if (m_IsAuthority == false)
{
m_OriginalKinematic = m_Rigidbody.isKinematic;
m_Rigidbody.isKinematic = true;
m_OriginalInterpolation = m_Rigidbody.interpolation;
// Set interpolation to none, the NetworkTransform component interpolates the position of the object.
m_Rigidbody.interpolation = RigidbodyInterpolation2D.None;
}
else
{
// Resets the rigidbody back to it's non replication only state. Happens on shutdown and when authority is lost
m_Rigidbody.isKinematic = m_OriginalKinematic;
m_Rigidbody.interpolation = m_OriginalInterpolation;
}
}
/// <inheritdoc />
public override void OnNetworkSpawn()
{
m_IsAuthority = HasAuthority;
m_OriginalKinematic = m_Rigidbody.isKinematic;
m_OriginalInterpolation = m_Rigidbody.interpolation;
UpdateRigidbodyKinematicMode();
}
/// <inheritdoc />
public override void OnNetworkDespawn()
{
UpdateRigidbodyKinematicMode();
} }
} }
} }

881
Components/NetworkTransform.cs
View File

File diff suppressed because it is too large Load Diff

230
Components/RigidbodyContactEventManager.cs Normal file
View File

@@ -0,0 +1,230 @@
#if COM_UNITY_MODULES_PHYSICS
using System.Collections.Generic;
using Unity.Collections;
using Unity.Jobs;
using UnityEngine;
namespace Unity.Netcode.Components
{
public interface IContactEventHandler
{
Rigidbody GetRigidbody();
void ContactEvent(ulong eventId, Vector3 averagedCollisionNormal, Rigidbody collidingBody, Vector3 contactPoint, bool hasCollisionStay = false, Vector3 averagedCollisionStayNormal = default);
}
[AddComponentMenu("Netcode/Rigidbody Contact Event Manager")]
public class RigidbodyContactEventManager : MonoBehaviour
{
public static RigidbodyContactEventManager Instance { get; private set; }
private struct JobResultStruct
{
public bool HasCollisionStay;
public int ThisInstanceID;
public int OtherInstanceID;
public Vector3 AverageNormal;
public Vector3 AverageCollisionStayNormal;
public Vector3 ContactPoint;
}
private NativeArray<JobResultStruct> m_ResultsArray;
private int m_Count = 0;
private JobHandle m_JobHandle;
private readonly Dictionary<int, Rigidbody> m_RigidbodyMapping = new Dictionary<int, Rigidbody>();
private readonly Dictionary<int, IContactEventHandler> m_HandlerMapping = new Dictionary<int, IContactEventHandler>();
private void OnEnable()
{
m_ResultsArray = new NativeArray<JobResultStruct>(16, Allocator.Persistent);
Physics.ContactEvent += Physics_ContactEvent;
if (Instance != null)
{
NetworkLog.LogError($"[Invalid][Multiple Instances] Found more than one instance of {nameof(RigidbodyContactEventManager)}: {name} and {Instance.name}");
NetworkLog.LogError($"[Disable][Additional Instance] Disabling {name} instance!");
gameObject.SetActive(false);
return;
}
Instance = this;
}
public void RegisterHandler(IContactEventHandler contactEventHandler, bool register = true)
{
var rigidbody = contactEventHandler.GetRigidbody();
var instanceId = rigidbody.GetInstanceID();
if (register)
{
if (!m_RigidbodyMapping.ContainsKey(instanceId))
{
m_RigidbodyMapping.Add(instanceId, rigidbody);
}
if (!m_HandlerMapping.ContainsKey(instanceId))
{
m_HandlerMapping.Add(instanceId, contactEventHandler);
}
}
else
{
m_RigidbodyMapping.Remove(instanceId);
m_HandlerMapping.Remove(instanceId);
}
}
private void OnDisable()
{
m_JobHandle.Complete();
m_ResultsArray.Dispose();
Physics.ContactEvent -= Physics_ContactEvent;
m_RigidbodyMapping.Clear();
Instance = null;
}
private bool m_HasCollisions;
private int m_CurrentCount = 0;
private void ProcessCollisions()
{
// Process all collisions
for (int i = 0; i < m_Count; i++)
{
var thisInstanceID = m_ResultsArray[i].ThisInstanceID;
var otherInstanceID = m_ResultsArray[i].OtherInstanceID;
var rb0Valid = thisInstanceID != 0 && m_RigidbodyMapping.ContainsKey(thisInstanceID);
var rb1Valid = otherInstanceID != 0 && m_RigidbodyMapping.ContainsKey(otherInstanceID);
// Only notify registered rigid bodies.
if (!rb0Valid || !rb1Valid || !m_HandlerMapping.ContainsKey(thisInstanceID))
{
continue;
}
if (m_ResultsArray[i].HasCollisionStay)
{
m_HandlerMapping[thisInstanceID].ContactEvent(m_EventId, m_ResultsArray[i].AverageNormal, m_RigidbodyMapping[otherInstanceID], m_ResultsArray[i].ContactPoint, m_ResultsArray[i].HasCollisionStay, m_ResultsArray[i].AverageCollisionStayNormal);
}
else
{
m_HandlerMapping[thisInstanceID].ContactEvent(m_EventId, m_ResultsArray[i].AverageNormal, m_RigidbodyMapping[otherInstanceID], m_ResultsArray[i].ContactPoint);
}
}
}
private void FixedUpdate()
{
// Only process new collisions
if (!m_HasCollisions && m_CurrentCount == 0)
{
return;
}
// This assures we won't process the same collision
// set after it has been processed.
if (m_HasCollisions)
{
m_CurrentCount = m_Count;
m_HasCollisions = false;
m_JobHandle.Complete();
}
ProcessCollisions();
}
private void LateUpdate()
{
m_CurrentCount = 0;
}
private ulong m_EventId;
private void Physics_ContactEvent(PhysicsScene scene, NativeArray<ContactPairHeader>.ReadOnly pairHeaders)
{
m_EventId++;
m_HasCollisions = true;
int n = pairHeaders.Length;
if (m_ResultsArray.Length < n)
{
m_ResultsArray.Dispose();
m_ResultsArray = new NativeArray<JobResultStruct>(Mathf.NextPowerOfTwo(n), Allocator.Persistent);
}
m_Count = n;
var job = new GetCollisionsJob()
{
PairedHeaders = pairHeaders,
ResultsArray = m_ResultsArray
};
m_JobHandle = job.Schedule(n, 256);
}
private struct GetCollisionsJob : IJobParallelFor
{
[ReadOnly]
public NativeArray<ContactPairHeader>.ReadOnly PairedHeaders;
public NativeArray<JobResultStruct> ResultsArray;
public void Execute(int index)
{
Vector3 averageNormal = Vector3.zero;
Vector3 averagePoint = Vector3.zero;
Vector3 averageCollisionStay = Vector3.zero;
int count = 0;
int collisionStaycount = 0;
int positionCount = 0;
for (int j = 0; j < PairedHeaders[index].pairCount; j++)
{
ref readonly var pair = ref PairedHeaders[index].GetContactPair(j);
if (pair.isCollisionExit)
{
continue;
}
for (int k = 0; k < pair.contactCount; k++)
{
ref readonly var contact = ref pair.GetContactPoint(k);
averagePoint += contact.position;
positionCount++;
if (!pair.isCollisionStay)
{
averageNormal += contact.normal;
count++;
}
else
{
averageCollisionStay += contact.normal;
collisionStaycount++;
}
}
}
if (count != 0)
{
averageNormal /= count;
}
if (collisionStaycount != 0)
{
averageCollisionStay /= collisionStaycount;
}
if (positionCount != 0)
{
averagePoint /= positionCount;
}
var result = new JobResultStruct()
{
ThisInstanceID = PairedHeaders[index].bodyInstanceID,
OtherInstanceID = PairedHeaders[index].otherBodyInstanceID,
AverageNormal = averageNormal,
HasCollisionStay = collisionStaycount != 0,
AverageCollisionStayNormal = averageCollisionStay,
ContactPoint = averagePoint
};
ResultsArray[index] = result;
}
}
}
}
#endif

11
Components/RigidbodyContactEventManager.cs.meta Normal file
View File

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

1
Editor/CodeGen/CodeGenHelpers.cs
View File

@@ -21,6 +21,7 @@ namespace Unity.Netcode.Editor.CodeGen
public const string NetcodeModuleName = "Unity.Netcode.Runtime.dll"; public const string NetcodeModuleName = "Unity.Netcode.Runtime.dll";
public const string RuntimeAssemblyName = "Unity.Netcode.Runtime"; public const string RuntimeAssemblyName = "Unity.Netcode.Runtime";
public const string ComponentsAssemblyName = "Unity.Netcode.Components";
public static readonly string NetworkBehaviour_FullName = typeof(NetworkBehaviour).FullName; public static readonly string NetworkBehaviour_FullName = typeof(NetworkBehaviour).FullName;
public static readonly string INetworkMessage_FullName = typeof(INetworkMessage).FullName; public static readonly string INetworkMessage_FullName = typeof(INetworkMessage).FullName;

2
Editor/CodeGen/INetworkMessageILPP.cs
View File

@@ -17,7 +17,7 @@ namespace Unity.Netcode.Editor.CodeGen
{ {
public override ILPPInterface GetInstance() => this; public override ILPPInterface GetInstance() => this;
public override bool WillProcess(ICompiledAssembly compiledAssembly) => compiledAssembly.Name == CodeGenHelpers.RuntimeAssemblyName; public override bool WillProcess(ICompiledAssembly compiledAssembly) => compiledAssembly.Name == CodeGenHelpers.RuntimeAssemblyName || compiledAssembly.Name == CodeGenHelpers.ComponentsAssemblyName;
private readonly List<DiagnosticMessage> m_Diagnostics = new List<DiagnosticMessage>(); private readonly List<DiagnosticMessage> m_Diagnostics = new List<DiagnosticMessage>();

153
Editor/CodeGen/NetworkBehaviourILPP.cs
View File

@@ -31,6 +31,43 @@ namespace Unity.Netcode.Editor.CodeGen
private readonly List<DiagnosticMessage> m_Diagnostics = new List<DiagnosticMessage>(); private readonly List<DiagnosticMessage> m_Diagnostics = new List<DiagnosticMessage>();
public void AddWrappedType(TypeReference wrappedType)
{
if (!m_WrappedNetworkVariableTypes.Contains(wrappedType))
{
m_WrappedNetworkVariableTypes.Add(wrappedType);
var resolved = wrappedType.Resolve();
if (resolved != null)
{
if (resolved.FullName == "System.Collections.Generic.List`1")
{
AddWrappedType(((GenericInstanceType)wrappedType).GenericArguments[0]);
}
if (resolved.FullName == "System.Collections.Generic.HashSet`1")
{
AddWrappedType(((GenericInstanceType)wrappedType).GenericArguments[0]);
}
else if (resolved.FullName == "System.Collections.Generic.Dictionary`2")
{
AddWrappedType(((GenericInstanceType)wrappedType).GenericArguments[0]);
AddWrappedType(((GenericInstanceType)wrappedType).GenericArguments[1]);
}
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
else if (resolved.FullName == "Unity.Collections.NativeHashSet`1")
{
AddWrappedType(((GenericInstanceType)wrappedType).GenericArguments[0]);
}
else if (resolved.FullName == "Unity.Collections.NativeHashMap`2")
{
AddWrappedType(((GenericInstanceType)wrappedType).GenericArguments[0]);
AddWrappedType(((GenericInstanceType)wrappedType).GenericArguments[1]);
}
#endif
}
}
}
public override ILPostProcessResult Process(ICompiledAssembly compiledAssembly) public override ILPostProcessResult Process(ICompiledAssembly compiledAssembly)
{ {
if (!WillProcess(compiledAssembly)) if (!WillProcess(compiledAssembly))
@@ -87,10 +124,7 @@ namespace Unity.Netcode.Editor.CodeGen
if (attribute.AttributeType.Name == nameof(GenerateSerializationForTypeAttribute)) if (attribute.AttributeType.Name == nameof(GenerateSerializationForTypeAttribute))
{ {
var wrappedType = mainModule.ImportReference((TypeReference)attribute.ConstructorArguments[0].Value); var wrappedType = mainModule.ImportReference((TypeReference)attribute.ConstructorArguments[0].Value);
if (!m_WrappedNetworkVariableTypes.Contains(wrappedType)) AddWrappedType(wrappedType);
{
m_WrappedNetworkVariableTypes.Add(wrappedType);
}
} }
} }
@@ -101,10 +135,7 @@ namespace Unity.Netcode.Editor.CodeGen
if (attribute.AttributeType.Name == nameof(GenerateSerializationForTypeAttribute)) if (attribute.AttributeType.Name == nameof(GenerateSerializationForTypeAttribute))
{ {
var wrappedType = mainModule.ImportReference((TypeReference)attribute.ConstructorArguments[0].Value); var wrappedType = mainModule.ImportReference((TypeReference)attribute.ConstructorArguments[0].Value);
if (!m_WrappedNetworkVariableTypes.Contains(wrappedType)) AddWrappedType(wrappedType);
{
m_WrappedNetworkVariableTypes.Add(wrappedType);
}
} }
} }
} }
@@ -241,6 +272,36 @@ namespace Unity.Netcode.Editor.CodeGen
serializeMethod?.GenericArguments.Add(wrappedType); serializeMethod?.GenericArguments.Add(wrappedType);
equalityMethod.GenericArguments.Add(wrappedType); equalityMethod.GenericArguments.Add(wrappedType);
} }
else if (type.Resolve().FullName == "System.Collections.Generic.List`1")
{
var wrappedType = ((GenericInstanceType)type).GenericArguments[0];
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_List_MethodRef);
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_List_MethodRef);
serializeMethod.GenericArguments.Add(wrappedType);
equalityMethod.GenericArguments.Add(wrappedType);
}
else if (type.Resolve().FullName == "System.Collections.Generic.HashSet`1")
{
var wrappedType = ((GenericInstanceType)type).GenericArguments[0];
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_HashSet_MethodRef);
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_HashSet_MethodRef);
serializeMethod.GenericArguments.Add(wrappedType);
equalityMethod.GenericArguments.Add(wrappedType);
}
else if (type.Resolve().FullName == "System.Collections.Generic.Dictionary`2")
{
var wrappedKeyType = ((GenericInstanceType)type).GenericArguments[0];
var wrappedValType = ((GenericInstanceType)type).GenericArguments[1];
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_Dictionary_MethodRef);
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_Dictionary_MethodRef);
serializeMethod.GenericArguments.Add(wrappedKeyType);
serializeMethod.GenericArguments.Add(wrappedValType);
equalityMethod.GenericArguments.Add(wrappedKeyType);
equalityMethod.GenericArguments.Add(wrappedValType);
}
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT #if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
else if (type.Resolve().FullName == "Unity.Collections.NativeList`1") else if (type.Resolve().FullName == "Unity.Collections.NativeList`1")
{ {
@@ -267,12 +328,30 @@ namespace Unity.Netcode.Editor.CodeGen
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsList_MethodRef); equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsList_MethodRef);
} }
if (serializeMethod != null) serializeMethod?.GenericArguments.Add(wrappedType);
{
serializeMethod.GenericArguments.Add(wrappedType);
}
equalityMethod.GenericArguments.Add(wrappedType); equalityMethod.GenericArguments.Add(wrappedType);
} }
else if (type.Resolve().FullName == "Unity.Collections.NativeHashSet`1")
{
var wrappedType = ((GenericInstanceType)type).GenericArguments[0];
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_NativeHashSet_MethodRef);
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_NativeHashSet_MethodRef);
serializeMethod.GenericArguments.Add(wrappedType);
equalityMethod.GenericArguments.Add(wrappedType);
}
else if (type.Resolve().FullName == "Unity.Collections.NativeHashMap`2")
{
var wrappedKeyType = ((GenericInstanceType)type).GenericArguments[0];
var wrappedValType = ((GenericInstanceType)type).GenericArguments[1];
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_NativeHashMap_MethodRef);
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_NativeHashMap_MethodRef);
serializeMethod.GenericArguments.Add(wrappedKeyType);
serializeMethod.GenericArguments.Add(wrappedValType);
equalityMethod.GenericArguments.Add(wrappedKeyType);
equalityMethod.GenericArguments.Add(wrappedValType);
}
#endif #endif
else if (type.IsValueType) else if (type.IsValueType)
{ {
@@ -398,7 +477,12 @@ namespace Unity.Netcode.Editor.CodeGen
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableArray_MethodRef; private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableArray_MethodRef;
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT #if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableList_MethodRef; private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableList_MethodRef;
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_NativeHashSet_MethodRef;
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_NativeHashMap_MethodRef;
#endif #endif
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_List_MethodRef;
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_HashSet_MethodRef;
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_Dictionary_MethodRef;
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_ManagedINetworkSerializable_MethodRef; private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_ManagedINetworkSerializable_MethodRef;
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_FixedString_MethodRef; private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_FixedString_MethodRef;
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_FixedStringArray_MethodRef; private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_FixedStringArray_MethodRef;
@@ -415,7 +499,12 @@ namespace Unity.Netcode.Editor.CodeGen
private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsArray_MethodRef; private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsArray_MethodRef;
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT #if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsList_MethodRef; private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsList_MethodRef;
private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_NativeHashSet_MethodRef;
private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_NativeHashMap_MethodRef;
#endif #endif
private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_List_MethodRef;
private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_HashSet_MethodRef;
private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_Dictionary_MethodRef;
private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedClassEquals_MethodRef; private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedClassEquals_MethodRef;
private MethodReference m_RuntimeInitializeOnLoadAttribute_Ctor; private MethodReference m_RuntimeInitializeOnLoadAttribute_Ctor;
@@ -940,7 +1029,22 @@ namespace Unity.Netcode.Editor.CodeGen
case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializableList): case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializableList):
m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableList_MethodRef = method; m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableList_MethodRef = method;
break; break;
case nameof(NetworkVariableSerializationTypes.InitializeSerializer_NativeHashSet):
m_NetworkVariableSerializationTypes_InitializeSerializer_NativeHashSet_MethodRef = method;
break;
case nameof(NetworkVariableSerializationTypes.InitializeSerializer_NativeHashMap):
m_NetworkVariableSerializationTypes_InitializeSerializer_NativeHashMap_MethodRef = method;
break;
#endif #endif
case nameof(NetworkVariableSerializationTypes.InitializeSerializer_List):
m_NetworkVariableSerializationTypes_InitializeSerializer_List_MethodRef = method;
break;
case nameof(NetworkVariableSerializationTypes.InitializeSerializer_HashSet):
m_NetworkVariableSerializationTypes_InitializeSerializer_HashSet_MethodRef = method;
break;
case nameof(NetworkVariableSerializationTypes.InitializeSerializer_Dictionary):
m_NetworkVariableSerializationTypes_InitializeSerializer_Dictionary_MethodRef = method;
break;
case nameof(NetworkVariableSerializationTypes.InitializeSerializer_ManagedINetworkSerializable): case nameof(NetworkVariableSerializationTypes.InitializeSerializer_ManagedINetworkSerializable):
m_NetworkVariableSerializationTypes_InitializeSerializer_ManagedINetworkSerializable_MethodRef = method; m_NetworkVariableSerializationTypes_InitializeSerializer_ManagedINetworkSerializable_MethodRef = method;
break; break;
@@ -971,7 +1075,22 @@ namespace Unity.Netcode.Editor.CodeGen
case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatableList): case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatableList):
m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatableList_MethodRef = method; m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatableList_MethodRef = method;
break; break;
case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_NativeHashSet):
m_NetworkVariableSerializationTypes_InitializeEqualityChecker_NativeHashSet_MethodRef = method;
break;
case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_NativeHashMap):
m_NetworkVariableSerializationTypes_InitializeEqualityChecker_NativeHashMap_MethodRef = method;
break;
#endif #endif
case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_List):
m_NetworkVariableSerializationTypes_InitializeEqualityChecker_List_MethodRef = method;
break;
case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_HashSet):
m_NetworkVariableSerializationTypes_InitializeEqualityChecker_HashSet_MethodRef = method;
break;
case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_Dictionary):
m_NetworkVariableSerializationTypes_InitializeEqualityChecker_Dictionary_MethodRef = method;
break;
case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEquals): case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEquals):
m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEquals_MethodRef = method; m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEquals_MethodRef = method;
break; break;
@@ -1246,10 +1365,7 @@ namespace Unity.Netcode.Editor.CodeGen
continue; continue;
} }
var wrappedType = genericInstanceType.GenericArguments[idx]; var wrappedType = genericInstanceType.GenericArguments[idx];
if (!m_WrappedNetworkVariableTypes.Contains(wrappedType)) AddWrappedType(wrappedType);
{
m_WrappedNetworkVariableTypes.Add(wrappedType);
}
} }
} }
} }
@@ -1282,10 +1398,7 @@ namespace Unity.Netcode.Editor.CodeGen
continue; continue;
} }
var wrappedType = genericInstanceType.GenericArguments[idx]; var wrappedType = genericInstanceType.GenericArguments[idx];
if (!m_WrappedNetworkVariableTypes.Contains(wrappedType)) AddWrappedType(wrappedType);
{
m_WrappedNetworkVariableTypes.Add(wrappedType);
}
} }
} }
} }

2
Editor/Configuration/NetcodeSettingsProvider.cs
View File

@@ -19,7 +19,7 @@ namespace Unity.Netcode.Editor.Configuration
{ {
// First parameter is the path in the Settings window. // First parameter is the path in the Settings window.
// Second parameter is the scope of this setting: it only appears in the Settings window for the Project scope. // Second parameter is the scope of this setting: it only appears in the Settings window for the Project scope.
var provider = new SettingsProvider("Project/NetcodeForGameObjects", SettingsScope.Project) var provider = new SettingsProvider("Project/Multiplayer/NetcodeForGameObjects", SettingsScope.Project)
{ {
label = "Netcode for GameObjects", label = "Netcode for GameObjects",
keywords = new[] { "netcode", "editor" }, keywords = new[] { "netcode", "editor" },

530
Editor/NetworkManagerEditor.cs
View File

@@ -1,6 +1,3 @@
#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;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
@@ -33,7 +30,7 @@ namespace Unity.Netcode.Editor
private SerializedProperty m_ProtocolVersionProperty; private SerializedProperty m_ProtocolVersionProperty;
private SerializedProperty m_NetworkTransportProperty; private SerializedProperty m_NetworkTransportProperty;
private SerializedProperty m_TickRateProperty; private SerializedProperty m_TickRateProperty;
private SerializedProperty m_MaxObjectUpdatesPerTickProperty; private SerializedProperty m_SessionModeProperty;
private SerializedProperty m_ClientConnectionBufferTimeoutProperty; private SerializedProperty m_ClientConnectionBufferTimeoutProperty;
private SerializedProperty m_ConnectionApprovalProperty; private SerializedProperty m_ConnectionApprovalProperty;
private SerializedProperty m_EnsureNetworkVariableLengthSafetyProperty; private SerializedProperty m_EnsureNetworkVariableLengthSafetyProperty;
@@ -41,6 +38,7 @@ namespace Unity.Netcode.Editor
private SerializedProperty m_EnableSceneManagementProperty; private SerializedProperty m_EnableSceneManagementProperty;
private SerializedProperty m_RecycleNetworkIdsProperty; private SerializedProperty m_RecycleNetworkIdsProperty;
private SerializedProperty m_NetworkIdRecycleDelayProperty; private SerializedProperty m_NetworkIdRecycleDelayProperty;
private SerializedProperty m_SpawnTimeOutProperty;
private SerializedProperty m_RpcHashSizeProperty; private SerializedProperty m_RpcHashSizeProperty;
private SerializedProperty m_LoadSceneTimeOutProperty; private SerializedProperty m_LoadSceneTimeOutProperty;
private SerializedProperty m_PrefabsList; private SerializedProperty m_PrefabsList;
@@ -51,27 +49,6 @@ namespace Unity.Netcode.Editor
private readonly List<Type> m_TransportTypes = new List<Type>(); private readonly List<Type> m_TransportTypes = new List<Type>();
private string[] m_TransportNames = { "Select transport..." }; 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() private void ReloadTransports()
{ {
m_TransportTypes.Clear(); m_TransportTypes.Clear();
@@ -120,15 +97,20 @@ namespace Unity.Netcode.Editor
m_ProtocolVersionProperty = m_NetworkConfigProperty.FindPropertyRelative("ProtocolVersion"); m_ProtocolVersionProperty = m_NetworkConfigProperty.FindPropertyRelative("ProtocolVersion");
m_NetworkTransportProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkTransport"); m_NetworkTransportProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkTransport");
m_TickRateProperty = m_NetworkConfigProperty.FindPropertyRelative("TickRate"); m_TickRateProperty = m_NetworkConfigProperty.FindPropertyRelative("TickRate");
m_SessionModeProperty = m_NetworkConfigProperty.FindPropertyRelative("SessionMode");
m_ClientConnectionBufferTimeoutProperty = m_NetworkConfigProperty.FindPropertyRelative("ClientConnectionBufferTimeout"); m_ClientConnectionBufferTimeoutProperty = m_NetworkConfigProperty.FindPropertyRelative("ClientConnectionBufferTimeout");
m_ConnectionApprovalProperty = m_NetworkConfigProperty.FindPropertyRelative("ConnectionApproval"); m_ConnectionApprovalProperty = m_NetworkConfigProperty.FindPropertyRelative("ConnectionApproval");
m_EnsureNetworkVariableLengthSafetyProperty = m_NetworkConfigProperty.FindPropertyRelative("EnsureNetworkVariableLengthSafety"); m_EnsureNetworkVariableLengthSafetyProperty = m_NetworkConfigProperty.FindPropertyRelative("EnsureNetworkVariableLengthSafety");
m_ForceSamePrefabsProperty = m_NetworkConfigProperty.FindPropertyRelative("ForceSamePrefabs"); m_ForceSamePrefabsProperty = m_NetworkConfigProperty.FindPropertyRelative("ForceSamePrefabs");
m_EnableSceneManagementProperty = m_NetworkConfigProperty.FindPropertyRelative("EnableSceneManagement");
m_RecycleNetworkIdsProperty = m_NetworkConfigProperty.FindPropertyRelative("RecycleNetworkIds"); m_RecycleNetworkIdsProperty = m_NetworkConfigProperty.FindPropertyRelative("RecycleNetworkIds");
m_NetworkIdRecycleDelayProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkIdRecycleDelay"); m_NetworkIdRecycleDelayProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkIdRecycleDelay");
m_RpcHashSizeProperty = m_NetworkConfigProperty.FindPropertyRelative("RpcHashSize");
m_EnableSceneManagementProperty = m_NetworkConfigProperty.FindPropertyRelative("EnableSceneManagement");
m_SpawnTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("SpawnTimeout");
m_LoadSceneTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("LoadSceneTimeOut"); m_LoadSceneTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("LoadSceneTimeOut");
m_RpcHashSizeProperty = m_NetworkConfigProperty.FindPropertyRelative("RpcHashSize");
m_PrefabsList = m_NetworkConfigProperty m_PrefabsList = m_NetworkConfigProperty
.FindPropertyRelative(nameof(NetworkConfig.Prefabs)) .FindPropertyRelative(nameof(NetworkConfig.Prefabs))
.FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists)); .FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists));
@@ -148,325 +130,213 @@ namespace Unity.Netcode.Editor
m_ProtocolVersionProperty = m_NetworkConfigProperty.FindPropertyRelative("ProtocolVersion"); m_ProtocolVersionProperty = m_NetworkConfigProperty.FindPropertyRelative("ProtocolVersion");
m_NetworkTransportProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkTransport"); m_NetworkTransportProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkTransport");
m_TickRateProperty = m_NetworkConfigProperty.FindPropertyRelative("TickRate"); m_TickRateProperty = m_NetworkConfigProperty.FindPropertyRelative("TickRate");
m_SessionModeProperty = m_NetworkConfigProperty.FindPropertyRelative("SessionMode");
m_ClientConnectionBufferTimeoutProperty = m_NetworkConfigProperty.FindPropertyRelative("ClientConnectionBufferTimeout"); m_ClientConnectionBufferTimeoutProperty = m_NetworkConfigProperty.FindPropertyRelative("ClientConnectionBufferTimeout");
m_ConnectionApprovalProperty = m_NetworkConfigProperty.FindPropertyRelative("ConnectionApproval"); m_ConnectionApprovalProperty = m_NetworkConfigProperty.FindPropertyRelative("ConnectionApproval");
m_EnsureNetworkVariableLengthSafetyProperty = m_NetworkConfigProperty.FindPropertyRelative("EnsureNetworkVariableLengthSafety"); m_EnsureNetworkVariableLengthSafetyProperty = m_NetworkConfigProperty.FindPropertyRelative("EnsureNetworkVariableLengthSafety");
m_ForceSamePrefabsProperty = m_NetworkConfigProperty.FindPropertyRelative("ForceSamePrefabs"); m_ForceSamePrefabsProperty = m_NetworkConfigProperty.FindPropertyRelative("ForceSamePrefabs");
m_EnableSceneManagementProperty = m_NetworkConfigProperty.FindPropertyRelative("EnableSceneManagement");
m_RecycleNetworkIdsProperty = m_NetworkConfigProperty.FindPropertyRelative("RecycleNetworkIds"); m_RecycleNetworkIdsProperty = m_NetworkConfigProperty.FindPropertyRelative("RecycleNetworkIds");
m_NetworkIdRecycleDelayProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkIdRecycleDelay"); m_NetworkIdRecycleDelayProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkIdRecycleDelay");
m_RpcHashSizeProperty = m_NetworkConfigProperty.FindPropertyRelative("RpcHashSize");
m_EnableSceneManagementProperty = m_NetworkConfigProperty.FindPropertyRelative("EnableSceneManagement");
m_SpawnTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("SpawnTimeout");
m_LoadSceneTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("LoadSceneTimeOut"); m_LoadSceneTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("LoadSceneTimeOut");
m_RpcHashSizeProperty = m_NetworkConfigProperty.FindPropertyRelative("RpcHashSize");
m_PrefabsList = m_NetworkConfigProperty m_PrefabsList = m_NetworkConfigProperty
.FindPropertyRelative(nameof(NetworkConfig.Prefabs)) .FindPropertyRelative(nameof(NetworkConfig.Prefabs))
.FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists)); .FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists));
} }
private void DrawAllPropertyFields() /// <inheritdoc/>
public override void OnInspectorGUI()
{ {
serializedObject.Update(); Initialize();
EditorGUILayout.PropertyField(m_RunInBackgroundProperty); CheckNullProperties();
EditorGUILayout.PropertyField(m_LogLevelProperty);
EditorGUILayout.Space();
EditorGUILayout.PropertyField(m_PlayerPrefabProperty); #if !MULTIPLAYER_TOOLS
EditorGUILayout.Space(); DrawInstallMultiplayerToolsTip();
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))
{
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();
}
private void DrawTransportField()
{
#if RELAY_INTEGRATION_AVAILABLE
var useRelay = EditorPrefs.GetBool(k_UseEasyRelayIntegrationKey, false);
#else
var useRelay = false;
#endif #endif
if (useRelay) if (!m_NetworkManager.IsServer && !m_NetworkManager.IsClient)
{ {
EditorGUILayout.HelpBox("Test connection with relay is enabled, so the default Unity Transport will be used", MessageType.Info); serializedObject.Update();
GUI.enabled = false; EditorGUILayout.PropertyField(m_RunInBackgroundProperty);
EditorGUILayout.PropertyField(m_LogLevelProperty);
EditorGUILayout.PropertyField(m_SessionModeProperty);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Network Settings", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_ProtocolVersionProperty);
EditorGUILayout.PropertyField(m_NetworkTransportProperty); EditorGUILayout.PropertyField(m_NetworkTransportProperty);
GUI.enabled = true; if (m_NetworkTransportProperty.objectReferenceValue == null)
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)
{ {
ReloadTransports(); EditorGUILayout.HelpBox("You have no transport selected. A transport is required for netcode to work. Which one do you want?", MessageType.Warning);
var transportComponent = m_NetworkManager.gameObject.GetComponent(m_TransportTypes[selection - 1]) ?? m_NetworkManager.gameObject.AddComponent(m_TransportTypes[selection - 1]); int selection = EditorGUILayout.Popup(0, m_TransportNames);
m_NetworkTransportProperty.objectReferenceValue = transportComponent;
Repaint(); 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.PropertyField(m_SpawnTimeOutProperty);
EditorGUILayout.PropertyField(m_ConnectionApprovalProperty);
#if RELAY_INTEGRATION_AVAILABLE if (m_NetworkManager.NetworkConfig.ConnectionApproval)
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"); EditorGUILayout.PropertyField(m_ClientConnectionBufferTimeoutProperty);
} }
} EditorGUILayout.PropertyField(m_EnsureNetworkVariableLengthSafetyProperty, new GUIContent("NetworkVariable Length Safety"));
EditorGUILayout.PropertyField(m_RecycleNetworkIdsProperty);
if (m_NetworkManager.NetworkConfig.RecycleNetworkIds)
{
EditorGUILayout.PropertyField(m_NetworkIdRecycleDelayProperty);
}
EditorGUILayout.PropertyField(m_RpcHashSizeProperty);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Prefab Settings", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_ForceSamePrefabsProperty);
EditorGUILayout.PropertyField(m_PlayerPrefabProperty, new GUIContent("Default Player Prefab"));
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 #else
var useRelay = false; var prefabStage = UnityEditor.Experimental.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
#endif #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);
}
string buttonDisabledReasonSuffix = ""; EditorGUILayout.Space();
EditorGUILayout.LabelField("Scene Management Settings", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_EnableSceneManagementProperty);
if (m_NetworkManager.NetworkConfig.EnableSceneManagement)
{
EditorGUILayout.PropertyField(m_LoadSceneTimeOutProperty);
}
if (!EditorApplication.isPlaying) serializedObject.ApplyModifiedProperties();
{
buttonDisabledReasonSuffix = ". This can only be done in play mode";
GUI.enabled = false;
}
if (useRelay)
{ // Start buttons below
ShowStartConnectionButtons_Relay(buttonDisabledReasonSuffix); {
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;
}
}
} }
else else
{ {
ShowStartConnectionButtons_Standard(buttonDisabledReasonSuffix); string instanceType = string.Empty;
}
if (!EditorApplication.isPlaying) if (m_NetworkManager.IsHost)
{
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; instanceType = "Host";
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;
}
});
} }
} else if (m_NetworkManager.IsServer)
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)) instanceType = "Server";
{ }
m_StartConnectionError = "Please provide a join code!"; else if (m_NetworkManager.IsClient)
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, instanceType = "Client";
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); EditorGUILayout.HelpBox("You cannot edit the NetworkConfig when a " + instanceType + " is running.", MessageType.Info);
GUILayout.EndVertical();
GUILayout.Space(2f);
GUILayout.EndHorizontal();
}
#endif
if (GUILayout.Button(new GUIContent($"Stop {instanceType}", $"Stops the {instanceType} instance."))) if (GUILayout.Button(new GUIContent("Stop " + instanceType, "Stops the " + instanceType + " instance.")))
{ {
#if RELAY_INTEGRATION_AVAILABLE m_NetworkManager.Shutdown();
m_JoinCode = ""; }
#endif
m_NetworkManager.Shutdown();
} }
} }
private const string k_InfoIconName = "console.infoicon";
private static void DrawInstallMultiplayerToolsTip() 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 getToolsText = "Access additional tools for multiplayer development by installing the Multiplayer Tools package in the Package Manager.";
const string openDocsButtonText = "Open Docs"; const string openDocsButtonText = "Open Docs";
const string dismissButtonText = "Dismiss"; const string dismissButtonText = "Dismiss";
const string targetUrl = "https://docs-multiplayer.unity3d.com/tools/current/install-tools"; const string targetUrl = "https://docs-multiplayer.unity3d.com/tools/current/install-tools";
const string infoIconName = "console.infoicon";
if (NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() != 0) if (NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() != 0)
{ {
@@ -497,7 +367,7 @@ namespace Unity.Netcode.Editor
GUILayout.FlexibleSpace(); GUILayout.FlexibleSpace();
GUILayout.BeginHorizontal(s_HelpBoxStyle, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false), GUILayout.MaxWidth(800)); GUILayout.BeginHorizontal(s_HelpBoxStyle, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false), GUILayout.MaxWidth(800));
{ {
GUILayout.Label(new GUIContent(EditorGUIUtility.IconContent(k_InfoIconName)), GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)); GUILayout.Label(new GUIContent(EditorGUIUtility.IconContent(infoIconName)), GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true));
GUILayout.Space(4); GUILayout.Space(4);
GUILayout.Label(getToolsText, s_CenteredWordWrappedLabelStyle, GUILayout.ExpandHeight(true)); GUILayout.Label(getToolsText, s_CenteredWordWrappedLabelStyle, GUILayout.ExpandHeight(true));
@@ -530,69 +400,5 @@ namespace Unity.Netcode.Editor
GUILayout.Space(10); 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);
}
}
} }
} }

50
Editor/NetworkObjectEditor.cs
View File

@@ -1,4 +1,5 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq;
using UnityEditor; using UnityEditor;
using UnityEngine; using UnityEngine;
@@ -49,6 +50,10 @@ namespace Unity.Netcode.Editor
{ {
var guiEnabled = GUI.enabled; var guiEnabled = GUI.enabled;
GUI.enabled = false; GUI.enabled = false;
if (m_NetworkObject.NetworkManager.DistributedAuthorityMode)
{
EditorGUILayout.PropertyField(serializedObject.FindProperty(nameof(NetworkObject.Ownership)));
}
EditorGUILayout.TextField(nameof(NetworkObject.GlobalObjectIdHash), m_NetworkObject.GlobalObjectIdHash.ToString()); EditorGUILayout.TextField(nameof(NetworkObject.GlobalObjectIdHash), m_NetworkObject.GlobalObjectIdHash.ToString());
EditorGUILayout.TextField(nameof(NetworkObject.NetworkObjectId), m_NetworkObject.NetworkObjectId.ToString()); EditorGUILayout.TextField(nameof(NetworkObject.NetworkObjectId), m_NetworkObject.NetworkObjectId.ToString());
EditorGUILayout.TextField(nameof(NetworkObject.OwnerClientId), m_NetworkObject.OwnerClientId.ToString()); EditorGUILayout.TextField(nameof(NetworkObject.OwnerClientId), m_NetworkObject.OwnerClientId.ToString());
@@ -138,4 +143,49 @@ namespace Unity.Netcode.Editor
NetworkBehaviourEditor.CheckForNetworkObject(m_GameObject, true); NetworkBehaviourEditor.CheckForNetworkObject(m_GameObject, true);
} }
} }
[CustomPropertyDrawer(typeof(NetworkObject.OwnershipStatus))]
public class NetworkObjectOwnership : PropertyDrawer
{
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
label = EditorGUI.BeginProperty(position, label, property);
// Don't allow modification while in play mode
EditorGUI.BeginDisabledGroup(EditorApplication.isPlaying);
// This is a temporary work around due to EditorGUI.EnumFlagsField having a bug in how it displays mask values.
// For now, we will just display the flags as a toggle and handle the masking of the value ourselves.
EditorGUILayout.BeginHorizontal();
var names = System.Enum.GetNames(typeof(NetworkObject.OwnershipStatus)).ToList();
names.RemoveAt(0);
var value = property.enumValueFlag;
var compareValue = 0x01;
GUILayout.Label(label);
foreach (var name in names)
{
var isSet = (value & compareValue) > 0;
isSet = GUILayout.Toggle(isSet, name);
if (isSet)
{
value |= compareValue;
}
else
{
value &= ~compareValue;
}
compareValue = compareValue << 1;
}
property.enumValueFlag = value;
EditorGUILayout.EndHorizontal();
// The below can cause visual anomalies and/or throws an exception within the EditorGUI itself (index out of bounds of the array). and has
// The visual anomaly is when you select one field it is set in the drop down but then the flags selection in the popup menu selects more items
// even though if you exit the popup menu the flag setting is correct.
//var ownership = (NetworkObject.OwnershipStatus)EditorGUI.EnumFlagsField(position, label, (NetworkObject.OwnershipStatus)property.enumValueFlag);
//property.enumValueFlag = (int)ownership;
EditorGUI.EndDisabledGroup();
EditorGUI.EndProperty();
}
}
} }

10
LICENSE.md
View File

@@ -1,9 +1,7 @@
MIT License Unity Companion License (UCL License)
Copyright (c) 2021 Unity Technologies com.unity.netcode.gameobjects copyright © 2021-2024 Unity Technologies
Licensed under the Unity Companion License for Unity-dependent projects (see https://unity3d.com/legal/licenses/unity_companion_license).
Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

13
Runtime/Configuration/NetworkConfig.cs
View File

@@ -129,9 +129,9 @@ namespace Unity.Netcode
public int LoadSceneTimeOut = 120; public int LoadSceneTimeOut = 120;
/// <summary> /// <summary>
/// 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. /// The amount of time a message will be held (deferred) if the destination NetworkObject needed to process the message doesn't exist yet. If the NetworkObject is not spawned within this time period, all deferred messages for that NetworkObject will be dropped.
/// </summary> /// </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")] [Tooltip("The amount of time a message will be held (deferred) if the destination NetworkObject needed to process the message doesn't exist yet. If the NetworkObject is not spawned within this time period, all deferred messages for that NetworkObject will be dropped.")]
public float SpawnTimeout = 10f; public float SpawnTimeout = 10f;
/// <summary> /// <summary>
@@ -149,6 +149,15 @@ namespace Unity.Netcode
/// </summary> /// </summary>
public const int RttWindowSize = 64; // number of slots to use for RTT computations (max number of in-flight packets) public const int RttWindowSize = 64; // number of slots to use for RTT computations (max number of in-flight packets)
[Tooltip("Determines if the network session will run in client-server or distributed authority mode.")]
public SessionModeTypes SessionMode;
[HideInInspector]
public bool UseCMBService;
[Tooltip("When enabled (default), the player prefab will automatically be spawned (client-side) upon the client being approved and synchronized.")]
public bool AutoSpawnPlayerPrefabClientSide = true;
/// <summary> /// <summary>
/// Returns a base64 encoded version of the configuration /// Returns a base64 encoded version of the configuration
/// </summary> /// </summary>

64
Runtime/Connection/NetworkClient.cs
View File

@@ -1,7 +1,15 @@
using System.Collections.Generic; using System.Collections.Generic;
using UnityEngine;
namespace Unity.Netcode namespace Unity.Netcode
{ {
public enum SessionModeTypes
{
ClientServer,
DistributedAuthority
}
/// <summary> /// <summary>
/// A NetworkClient /// A NetworkClient
/// </summary> /// </summary>
@@ -33,6 +41,15 @@ namespace Unity.Netcode
/// </summary> /// </summary>
internal bool IsApproved { get; set; } internal bool IsApproved { get; set; }
public SessionModeTypes SessionModeType { get; internal set; }
public bool DAHost { get; internal set; }
/// <summary>
/// Is true when the client has been assigned session ownership in distributed authority mode
/// </summary>
public bool IsSessionOwner { get; internal set; }
/// <summary> /// <summary>
/// The ClientId of the NetworkClient /// The ClientId of the NetworkClient
/// </summary> /// </summary>
@@ -50,21 +67,54 @@ namespace Unity.Netcode
internal NetworkSpawnManager SpawnManager { get; private set; } internal NetworkSpawnManager SpawnManager { get; private set; }
internal void SetRole(bool isServer, bool isClient, NetworkManager networkManager = null) internal bool SetRole(bool isServer, bool isClient, NetworkManager networkManager = null)
{ {
ResetClient(isServer, isClient);
IsServer = isServer; IsServer = isServer;
IsClient = isClient; IsClient = isClient;
if (!IsServer && !isClient)
if (networkManager != null)
{
SpawnManager = networkManager.SpawnManager;
SessionModeType = networkManager.NetworkConfig.SessionMode;
if (SessionModeType == SessionModeTypes.DistributedAuthority)
{
DAHost = IsClient && IsServer;
// DANGO-TODO: We might allow a dedicated mock CMB server, but for now do not allow this
if (!IsClient && IsServer)
{
Debug.LogError("You cannot start NetworkManager as a server when operating in distributed authority mode!");
return false;
}
if (DAHost && networkManager.CMBServiceConnection)
{
Debug.LogError("You cannot start a host when connecting to a distributed authority CMB Service!");
return false;
}
}
}
return true;
}
/// <summary>
/// Only to be invoked when setting the role.
/// This resets the current NetworkClient's properties.
/// </summary>
private void ResetClient(bool isServer, bool isClient)
{
// If we are niether client nor server, then reset properties (i.e. client has no role)
if (!IsServer && !IsClient)
{ {
PlayerObject = null; PlayerObject = null;
ClientId = 0; ClientId = 0;
IsConnected = false; IsConnected = false;
IsApproved = false; IsApproved = false;
} SpawnManager = null;
DAHost = false;
if (networkManager != null)
{
SpawnManager = networkManager.SpawnManager;
} }
} }

318
Runtime/Connection/NetworkConnectionManager.cs
View File

@@ -1,12 +1,12 @@
using System; using System;
using System.Collections; using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
using Unity.Collections; using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe; using Unity.Collections.LowLevel.Unsafe;
using Unity.Profiling; using Unity.Profiling;
using UnityEngine; using UnityEngine;
using Object = UnityEngine.Object;
namespace Unity.Netcode namespace Unity.Netcode
{ {
@@ -366,6 +366,10 @@ namespace Unity.Netcode
{ {
networkEvent = NetworkManager.NetworkConfig.NetworkTransport.PollEvent(out ulong transportClientId, out ArraySegment<byte> payload, out float receiveTime); networkEvent = NetworkManager.NetworkConfig.NetworkTransport.PollEvent(out ulong transportClientId, out ArraySegment<byte> payload, out float receiveTime);
HandleNetworkEvent(networkEvent, transportClientId, payload, receiveTime); HandleNetworkEvent(networkEvent, transportClientId, payload, receiveTime);
if (networkEvent == NetworkEvent.Disconnect || networkEvent == NetworkEvent.TransportFailure)
{
break;
}
// Only do another iteration if: there are no more messages AND (there is no limit to max events or we have processed less than the maximum) // Only do another iteration if: there are no more messages AND (there is no limit to max events or we have processed less than the maximum)
} while (NetworkManager.IsListening && networkEvent != NetworkEvent.Nothing); } while (NetworkManager.IsListening && networkEvent != NetworkEvent.Nothing);
@@ -430,16 +434,17 @@ namespace Unity.Netcode
{ {
if (NetworkLog.CurrentLogLevel <= LogLevel.Developer) if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
{ {
NetworkLog.LogInfo("Client Connected"); var hostServer = NetworkManager.IsHost ? "Host" : "Server";
NetworkLog.LogInfo($"[{hostServer}-Side] Transport connection established with pending Client-{clientId}.");
} }
AddPendingClient(clientId); AddPendingClient(clientId);
} }
else else
{ {
if (NetworkLog.CurrentLogLevel <= LogLevel.Developer) if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
{ {
NetworkLog.LogInfo("Connected"); var serverOrService = NetworkManager.DistributedAuthorityMode ? NetworkManager.CMBServiceConnection ? "service" : "DAHost" : "server";
NetworkLog.LogInfo($"[Approval Pending][Client] Transport connection with {serverOrService} established! Awaiting connection approval...");
} }
SendConnectionRequest(); SendConnectionRequest();
@@ -546,6 +551,10 @@ namespace Unity.Netcode
{ {
var message = new ConnectionRequestMessage var message = new ConnectionRequestMessage
{ {
CMBServiceConnection = NetworkManager.CMBServiceConnection,
TickRate = NetworkManager.NetworkConfig.TickRate,
EnableSceneManagement = NetworkManager.NetworkConfig.EnableSceneManagement,
// Since only a remote client will send a connection request, we should always force the rebuilding of the NetworkConfig hash value // Since only a remote client will send a connection request, we should always force the rebuilding of the NetworkConfig hash value
ConfigHash = NetworkManager.NetworkConfig.GetConfig(false), ConfigHash = NetworkManager.NetworkConfig.GetConfig(false),
ShouldSendConnectionData = NetworkManager.NetworkConfig.ConnectionApproval, ShouldSendConnectionData = NetworkManager.NetworkConfig.ConnectionApproval,
@@ -701,6 +710,12 @@ namespace Unity.Netcode
} }
} }
/// <summary>
/// Adding this because message hooks cannot happen fast enough under certain scenarios
/// where the message is sent and responded to before the hook is in place.
/// </summary>
internal bool MockSkippingApproval;
/// <summary> /// <summary>
/// Server Side: Handles the approval of a client /// Server Side: Handles the approval of a client
/// </summary> /// </summary>
@@ -712,12 +727,15 @@ namespace Unity.Netcode
LocalClient.IsApproved = response.Approved; LocalClient.IsApproved = response.Approved;
if (response.Approved) if (response.Approved)
{ {
if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
{
NetworkLog.LogInfo($"[Server-Side] Pending Client-{ownerClientId} connection approved!");
}
// The client was approved, stop the server-side approval time out coroutine // The client was approved, stop the server-side approval time out coroutine
RemovePendingClient(ownerClientId); RemovePendingClient(ownerClientId);
var client = AddClient(ownerClientId); var client = AddClient(ownerClientId);
if (!NetworkManager.DistributedAuthorityMode && response.CreatePlayerObject && NetworkManager.NetworkConfig.PlayerPrefab != null)
if (response.CreatePlayerObject)
{ {
var prefabNetworkObject = NetworkManager.NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>(); var prefabNetworkObject = NetworkManager.NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>();
var playerPrefabHash = response.PlayerPrefabHash ?? prefabNetworkObject.GlobalObjectIdHash; var playerPrefabHash = response.PlayerPrefabHash ?? prefabNetworkObject.GlobalObjectIdHash;
@@ -732,6 +750,7 @@ namespace Unity.Netcode
HasTransform = prefabNetworkObject.SynchronizeTransform, HasTransform = prefabNetworkObject.SynchronizeTransform,
Hash = playerPrefabHash, Hash = playerPrefabHash,
TargetClientId = ownerClientId, TargetClientId = ownerClientId,
DontDestroyWithOwner = prefabNetworkObject.DontDestroyWithOwner,
Transform = new NetworkObject.SceneObject.TransformData Transform = new NetworkObject.SceneObject.TransformData
{ {
Position = response.Position.GetValueOrDefault(), Position = response.Position.GetValueOrDefault(),
@@ -761,6 +780,7 @@ namespace Unity.Netcode
{ {
OwnerClientId = ownerClientId, OwnerClientId = ownerClientId,
NetworkTick = NetworkManager.LocalTime.Tick, NetworkTick = NetworkManager.LocalTime.Tick,
IsDistributedAuthority = NetworkManager.DistributedAuthorityMode,
ConnectedClientIds = new NativeArray<ulong>(ConnectedClientIds.Count, Allocator.Temp) ConnectedClientIds = new NativeArray<ulong>(ConnectedClientIds.Count, Allocator.Temp)
}; };
@@ -794,10 +814,20 @@ namespace Unity.Netcode
}; };
} }
} }
if (!MockSkippingApproval)
SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ownerClientId); {
SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ownerClientId);
}
else
{
NetworkLog.LogInfo("Mocking server not responding with connection approved...");
}
message.MessageVersions.Dispose(); message.MessageVersions.Dispose();
message.ConnectedClientIds.Dispose(); message.ConnectedClientIds.Dispose();
if (MockSkippingApproval)
{
return;
}
// If scene management is disabled, then we are done and notify the local host-server the client is connected // If scene management is disabled, then we are done and notify the local host-server the client is connected
if (!NetworkManager.NetworkConfig.EnableSceneManagement) if (!NetworkManager.NetworkConfig.EnableSceneManagement)
@@ -808,10 +838,19 @@ namespace Unity.Netcode
{ {
InvokeOnPeerConnectedCallback(ownerClientId); InvokeOnPeerConnectedCallback(ownerClientId);
} }
NetworkManager.SpawnManager.DistributeNetworkObjects(ownerClientId);
} }
else // Otherwise, let NetworkSceneManager handle the initial scene and NetworkObject synchronization else // Otherwise, let NetworkSceneManager handle the initial scene and NetworkObject synchronization
{ {
NetworkManager.SceneManager.SynchronizeNetworkObjects(ownerClientId); if (NetworkManager.DistributedAuthorityMode && NetworkManager.LocalClient.IsSessionOwner)
{
NetworkManager.SceneManager.SynchronizeNetworkObjects(ownerClientId);
}
else if (!NetworkManager.DistributedAuthorityMode)
{
NetworkManager.SceneManager.SynchronizeNetworkObjects(ownerClientId);
}
} }
} }
else // Server just adds itself as an observer to all spawned NetworkObjects else // Server just adds itself as an observer to all spawned NetworkObjects
@@ -819,6 +858,17 @@ namespace Unity.Netcode
LocalClient = client; LocalClient = client;
NetworkManager.SpawnManager.UpdateObservedNetworkObjects(ownerClientId); NetworkManager.SpawnManager.UpdateObservedNetworkObjects(ownerClientId);
LocalClient.IsConnected = true; LocalClient.IsConnected = true;
// If running mock service, then set the instance as the default session owner
if (NetworkManager.DistributedAuthorityMode && NetworkManager.DAHost)
{
NetworkManager.SetSessionOwner(NetworkManager.LocalClientId);
NetworkManager.SceneManager.InitializeScenesLoaded();
}
if (NetworkManager.DistributedAuthorityMode && NetworkManager.AutoSpawnPlayerPrefabClientSide)
{
CreateAndSpawnPlayer(ownerClientId);
}
} }
if (!response.CreatePlayerObject || (response.PlayerPrefabHash == null && NetworkManager.NetworkConfig.PlayerPrefab == null)) if (!response.CreatePlayerObject || (response.PlayerPrefabHash == null && NetworkManager.NetworkConfig.PlayerPrefab == null))
@@ -826,6 +876,11 @@ namespace Unity.Netcode
return; return;
} }
// Players are always spawned by their respective client, exit early. (DAHost mode anyway, CMB Service will never spawn player prefab)
if (NetworkManager.DistributedAuthorityMode)
{
return;
}
// Separating this into a contained function call for potential further future separation of when this notification is sent. // Separating this into a contained function call for potential further future separation of when this notification is sent.
ApprovedPlayerSpawn(ownerClientId, response.PlayerPrefabHash ?? NetworkManager.NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash); ApprovedPlayerSpawn(ownerClientId, response.PlayerPrefabHash ?? NetworkManager.NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash);
} }
@@ -840,11 +895,28 @@ namespace Unity.Netcode
SendMessage(ref disconnectReason, NetworkDelivery.Reliable, ownerClientId); SendMessage(ref disconnectReason, NetworkDelivery.Reliable, ownerClientId);
MessageManager.ProcessSendQueues(); MessageManager.ProcessSendQueues();
} }
DisconnectRemoteClient(ownerClientId); DisconnectRemoteClient(ownerClientId);
} }
} }
/// <summary>
/// Client-Side Spawning in distributed authority mode uses this to spawn the player.
/// </summary>
internal void CreateAndSpawnPlayer(ulong ownerId, Vector3 position = default, Quaternion rotation = default)
{
if (NetworkManager.DistributedAuthorityMode && NetworkManager.AutoSpawnPlayerPrefabClientSide)
{
var playerPrefab = NetworkManager.FetchLocalPlayerPrefabToSpawn();
if (playerPrefab != null)
{
var globalObjectIdHash = playerPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash;
var networkObject = NetworkManager.SpawnManager.GetNetworkObjectToSpawn(globalObjectIdHash, ownerId, position, rotation);
networkObject.IsSceneObject = false;
networkObject.SpawnAsPlayerObject(ownerId, networkObject.DestroyWithScene);
}
}
}
/// <summary> /// <summary>
/// Spawns the newly approved player /// Spawns the newly approved player
/// </summary> /// </summary>
@@ -864,8 +936,10 @@ namespace Unity.Netcode
var message = new CreateObjectMessage var message = new CreateObjectMessage
{ {
ObjectInfo = ConnectedClients[clientId].PlayerObject.GetMessageSceneObject(clientPair.Key) ObjectInfo = ConnectedClients[clientId].PlayerObject.GetMessageSceneObject(clientPair.Key),
IncludesSerializedObject = true,
}; };
message.ObjectInfo.Hash = playerPrefabHash; message.ObjectInfo.Hash = playerPrefabHash;
message.ObjectInfo.IsSceneObject = false; message.ObjectInfo.IsSceneObject = false;
message.ObjectInfo.HasParent = false; message.ObjectInfo.HasParent = false;
@@ -883,20 +957,92 @@ namespace Unity.Netcode
/// </summary> /// </summary>
internal NetworkClient AddClient(ulong clientId) internal NetworkClient AddClient(ulong clientId)
{ {
if (ConnectedClients.ContainsKey(clientId) && ConnectedClientIds.Contains(clientId) && ConnectedClientsList.Contains(ConnectedClients[clientId]))
{
return ConnectedClients[clientId];
}
var networkClient = LocalClient; var networkClient = LocalClient;
networkClient = new NetworkClient(); // If this is not the local client then create a new one
if (clientId != NetworkManager.LocalClientId)
{
networkClient = new NetworkClient();
}
networkClient.SetRole(clientId == NetworkManager.ServerClientId, isClient: true, NetworkManager); networkClient.SetRole(clientId == NetworkManager.ServerClientId, isClient: true, NetworkManager);
networkClient.ClientId = clientId; networkClient.ClientId = clientId;
if (!ConnectedClients.ContainsKey(clientId))
{
ConnectedClients.Add(clientId, networkClient);
}
if (!ConnectedClientsList.Contains(networkClient))
{
ConnectedClientsList.Add(networkClient);
}
if (NetworkManager.LocalClientId != clientId)
{
if ((!NetworkManager.DistributedAuthorityMode && NetworkManager.IsServer) ||
(NetworkManager.DistributedAuthorityMode && NetworkManager.NetworkConfig.EnableSceneManagement && NetworkManager.DAHost && NetworkManager.LocalClient.IsSessionOwner))
{
var message = new ClientConnectedMessage { ClientId = clientId };
NetworkManager.MessageManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, ConnectedClientIds.Where((c) => c != NetworkManager.LocalClientId).ToArray());
}
else if (NetworkManager.DistributedAuthorityMode && NetworkManager.NetworkConfig.EnableSceneManagement && NetworkManager.DAHost && !NetworkManager.LocalClient.IsSessionOwner)
{
var message = new ClientConnectedMessage
{
ShouldSynchronize = true,
ClientId = clientId
};
NetworkManager.MessageManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, NetworkManager.CurrentSessionOwner);
}
}
if (!ConnectedClientIds.Contains(clientId))
{
ConnectedClientIds.Add(clientId);
}
foreach (var networkObject in NetworkManager.SpawnManager.SpawnedObjectsList)
{
if (networkObject.SpawnWithObservers)
{
networkObject.Observers.Add(clientId);
}
}
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; return networkClient;
} }
/// <summary>
/// Invoked on clients when another client disconnects
/// </summary>
/// <param name="clientId">the client identifier to remove</param>
internal void RemoveClient(ulong clientId)
{
if (ConnectedClientIds.Contains(clientId))
{
ConnectedClientIds.Remove(clientId);
}
if (ConnectedClients.ContainsKey(clientId))
{
ConnectedClientsList.Remove(ConnectedClients[clientId]);
}
ConnectedClients.Remove(clientId);
foreach (var networkObject in NetworkManager.SpawnManager.SpawnedObjectsList)
{
networkObject.Observers.Remove(clientId);
}
}
/// <summary>
/// DANGO-TODO: Until we have the CMB Server end-to-end with all features verified working via integration tests,
/// I am keeping this debug toggle available. (NSS)
/// </summary>
internal bool EnableDistributeLogging;
/// <summary> /// <summary>
/// Server-Side: /// Server-Side:
/// Invoked when a client is disconnected from a server-host /// Invoked when a client is disconnected from a server-host
@@ -923,25 +1069,55 @@ namespace Unity.Netcode
{ {
if (!playerObject.DontDestroyWithOwner) if (!playerObject.DontDestroyWithOwner)
{ {
if (NetworkManager.PrefabHandler.ContainsHandler(ConnectedClients[clientId].PlayerObject.GlobalObjectIdHash)) // DANGO-TODO: This is something that would be best for CMB Service to handle as it is part of the disconnection process
// If a player NetworkObject is being despawned, make sure to remove all children if they are marked to not be destroyed
// with the owner.
if (NetworkManager.DistributedAuthorityMode && NetworkManager.DAHost)
{ {
NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(ConnectedClients[clientId].PlayerObject); // Remove any children from the player object if they are not going to be destroyed with the owner
var childNetworkObjects = playerObject.GetComponentsInChildren<NetworkObject>();
foreach (var child in childNetworkObjects)
{
// TODO: We have always just removed all children, but we might think about changing this to preserve the nested child
// hierarchy.
if (child.DontDestroyWithOwner && child.transform.transform.parent != null)
{
// If we are here, then we are running in DAHost mode and have the authority to remove the child from its parent
child.AuthorityAppliedParenting = true;
child.TryRemoveParentCachedWorldPositionStays();
}
}
}
if (NetworkManager.PrefabHandler.ContainsHandler(playerObject.GlobalObjectIdHash))
{
if (NetworkManager.DAHost && NetworkManager.DistributedAuthorityMode)
{
NetworkManager.SpawnManager.DespawnObject(playerObject, true, NetworkManager.DistributedAuthorityMode);
}
else
{
NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(playerObject);
}
} }
else if (playerObject.IsSpawned) else if (playerObject.IsSpawned)
{ {
// Call despawn to assure NetworkBehaviour.OnNetworkDespawn is invoked on the server-side (when the client side disconnected). // Call despawn to assure NetworkBehaviour.OnNetworkDespawn is invoked on the server-side (when the client side disconnected).
// This prevents the issue (when just destroying the GameObject) where any NetworkBehaviour component(s) destroyed before the NetworkObject would not have OnNetworkDespawn invoked. // This prevents the issue (when just destroying the GameObject) where any NetworkBehaviour component(s) destroyed before the NetworkObject would not have OnNetworkDespawn invoked.
NetworkManager.SpawnManager.DespawnObject(playerObject, true); NetworkManager.SpawnManager.DespawnObject(playerObject, true, NetworkManager.DistributedAuthorityMode);
} }
} }
else if (!NetworkManager.ShutdownInProgress) else if (!NetworkManager.ShutdownInProgress)
{ {
playerObject.RemoveOwnership(); if (!NetworkManager.ShutdownInProgress)
{
playerObject.RemoveOwnership();
}
} }
} }
// Get the NetworkObjects owned by the disconnected client // Get the NetworkObjects owned by the disconnected client
var clientOwnedObjects = NetworkManager.SpawnManager.GetClientOwnedObjects(clientId); var clientOwnedObjects = NetworkManager.SpawnManager.SpawnedObjectsList.Where((c) => c.OwnerClientId == clientId).ToList();
if (clientOwnedObjects == null) if (clientOwnedObjects == null)
{ {
// This could happen if a client is never assigned a player object and is disconnected // This could happen if a client is never assigned a player object and is disconnected
@@ -954,6 +1130,9 @@ namespace Unity.Netcode
else else
{ {
// Handle changing ownership and prefab handlers // Handle changing ownership and prefab handlers
var clientCounter = 0;
var predictedClientCount = ConnectedClientsList.Count - 1;
var remainingClients = NetworkManager.DistributedAuthorityMode ? ConnectedClientsList.Where((c) => c.ClientId != clientId).ToList() : null;
for (int i = clientOwnedObjects.Count - 1; i >= 0; i--) for (int i = clientOwnedObjects.Count - 1; i >= 0; i--)
{ {
var ownedObject = clientOwnedObjects[i]; var ownedObject = clientOwnedObjects[i];
@@ -963,16 +1142,72 @@ namespace Unity.Netcode
{ {
if (NetworkManager.PrefabHandler.ContainsHandler(clientOwnedObjects[i].GlobalObjectIdHash)) if (NetworkManager.PrefabHandler.ContainsHandler(clientOwnedObjects[i].GlobalObjectIdHash))
{ {
NetworkManager.SpawnManager.DespawnObject(ownedObject, true, true);
NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(clientOwnedObjects[i]); NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(clientOwnedObjects[i]);
} }
else else
{ {
Object.Destroy(ownedObject.gameObject); NetworkManager.SpawnManager.DespawnObject(ownedObject, true, true);
} }
} }
else if (!NetworkManager.ShutdownInProgress) else if (!NetworkManager.ShutdownInProgress)
{ {
ownedObject.RemoveOwnership(); // NOTE: All of the below code only handles ownership transfer.
// For client-server, we just remove the ownership.
// For distributed authority, we need to change ownership based on parenting
if (NetworkManager.DistributedAuthorityMode)
{
// Only NetworkObjects that have the OwnershipStatus.Distributable flag set and no parent
// (ownership is transferred to all children) will have their ownership redistributed.
if (ownedObject.IsOwnershipDistributable && ownedObject.GetCachedParent() == null)
{
if (ownedObject.IsOwnershipLocked)
{
ownedObject.SetOwnershipLock(false);
}
// DANGO-TODO: We will want to match how the CMB service handles this. For now, we just try to evenly distribute
// ownership.
var targetOwner = NetworkManager.ServerClientId;
if (predictedClientCount > 1)
{
clientCounter++;
clientCounter = clientCounter % predictedClientCount;
targetOwner = remainingClients[clientCounter].ClientId;
}
if (EnableDistributeLogging)
{
Debug.Log($"[Disconnected][Client-{clientId}][NetworkObjectId-{ownedObject.NetworkObjectId} Distributed to Client-{targetOwner}");
}
NetworkManager.SpawnManager.ChangeOwnership(ownedObject, targetOwner, true);
// DANGO-TODO: Should we try handling inactive NetworkObjects?
// Ownership gets passed down to all children
var childNetworkObjects = ownedObject.GetComponentsInChildren<NetworkObject>();
foreach (var childObject in childNetworkObjects)
{
// We already changed ownership for this
if (childObject == ownedObject)
{
continue;
}
// If the client owner disconnected, it is ok to unlock this at this point in time.
if (childObject.IsOwnershipLocked)
{
childObject.SetOwnershipLock(false);
}
NetworkManager.SpawnManager.ChangeOwnership(childObject, targetOwner, true);
if (EnableDistributeLogging)
{
Debug.Log($"[Disconnected][Client-{clientId}][Child of {ownedObject.NetworkObjectId}][NetworkObjectId-{ownedObject.NetworkObjectId} Distributed to Client-{targetOwner}");
}
}
}
}
else
{
ownedObject.RemoveOwnership();
}
} }
} }
} }
@@ -993,6 +1228,37 @@ namespace Unity.Netcode
ConnectedClientIds.Remove(clientId); ConnectedClientIds.Remove(clientId);
var message = new ClientDisconnectedMessage { ClientId = clientId }; var message = new ClientDisconnectedMessage { ClientId = clientId };
MessageManager?.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ConnectedClientIds); MessageManager?.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ConnectedClientIds);
if (NetworkManager.DistributedAuthorityMode && !NetworkManager.ShutdownInProgress && NetworkManager.IsListening)
{
var newSessionOwner = NetworkManager.LocalClientId;
if (ConnectedClientIds.Count > 1)
{
var lowestRTT = ulong.MaxValue;
var unityTransport = NetworkManager.NetworkConfig.NetworkTransport as Transports.UTP.UnityTransport;
foreach (var identifier in ConnectedClientIds)
{
if (identifier == NetworkManager.LocalClientId)
{
continue;
}
var rtt = unityTransport.GetCurrentRtt(identifier);
if (rtt < lowestRTT)
{
newSessionOwner = identifier;
lowestRTT = rtt;
}
}
}
var sessionOwnerMessage = new SessionOwnerMessage()
{
SessionOwner = newSessionOwner,
};
MessageManager?.SendMessage(ref sessionOwnerMessage, NetworkDelivery.ReliableFragmentedSequenced, ConnectedClientIds);
NetworkManager.SetSessionOwner(newSessionOwner);
}
} }
// If the client ID transport map exists // If the client ID transport map exists
@@ -1259,8 +1525,8 @@ namespace Unity.Netcode
internal int SendMessage<T>(ref T message, NetworkDelivery delivery, ulong clientId) internal int SendMessage<T>(ref T message, NetworkDelivery delivery, ulong clientId)
where T : INetworkMessage where T : INetworkMessage
{ {
// Prevent server sending to itself // Prevent server sending to itself or if there is no MessageManager yet then exit early
if (LocalClient.IsServer && clientId == NetworkManager.ServerClientId) if ((LocalClient.IsServer && clientId == NetworkManager.ServerClientId) || MessageManager == null)
{ {
return 0; return 0;
} }

286
Runtime/Core/NetworkBehaviour.cs
View File

@@ -69,6 +69,7 @@ namespace Unity.Netcode
internal void __endSendServerRpc(ref FastBufferWriter bufferWriter, uint rpcMethodId, ServerRpcParams serverRpcParams, RpcDelivery rpcDelivery) internal void __endSendServerRpc(ref FastBufferWriter bufferWriter, uint rpcMethodId, ServerRpcParams serverRpcParams, RpcDelivery rpcDelivery)
#pragma warning restore IDE1006 // restore naming rule violation check #pragma warning restore IDE1006 // restore naming rule violation check
{ {
var networkManager = NetworkManager;
var serverRpcMessage = new ServerRpcMessage var serverRpcMessage = new ServerRpcMessage
{ {
Metadata = new RpcMetadata Metadata = new RpcMetadata
@@ -88,7 +89,7 @@ namespace Unity.Netcode
networkDelivery = NetworkDelivery.ReliableFragmentedSequenced; networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
break; break;
case RpcDelivery.Unreliable: case RpcDelivery.Unreliable:
if (bufferWriter.Length > NetworkManager.MessageManager.NonFragmentedMessageMaxSize) if (bufferWriter.Length > networkManager.MessageManager.NonFragmentedMessageMaxSize)
{ {
throw new OverflowException("RPC parameters are too large for unreliable delivery."); throw new OverflowException("RPC parameters are too large for unreliable delivery.");
} }
@@ -97,16 +98,16 @@ namespace Unity.Netcode
} }
var rpcWriteSize = 0; var rpcWriteSize = 0;
// Authority just no ops and sends to itself
// If we are a server/host then we just no op and send to ourself // Client-Server: Only the server-host sends to self
if (IsHost || IsServer) if (IsServer)
{ {
using var tempBuffer = new FastBufferReader(bufferWriter, Allocator.Temp); using var tempBuffer = new FastBufferReader(bufferWriter, Allocator.Temp);
var context = new NetworkContext var context = new NetworkContext
{ {
SenderId = NetworkManager.ServerClientId, SenderId = NetworkManager.ServerClientId,
Timestamp = NetworkManager.RealTimeProvider.RealTimeSinceStartup, Timestamp = networkManager.RealTimeProvider.RealTimeSinceStartup,
SystemOwner = NetworkManager, SystemOwner = networkManager,
// header information isn't valid since it's not a real message. // header information isn't valid since it's not a real message.
// RpcMessage doesn't access this stuff so it's just left empty. // RpcMessage doesn't access this stuff so it's just left empty.
Header = new NetworkMessageHeader(), Header = new NetworkMessageHeader(),
@@ -149,6 +150,7 @@ namespace Unity.Netcode
internal void __endSendClientRpc(ref FastBufferWriter bufferWriter, uint rpcMethodId, ClientRpcParams clientRpcParams, RpcDelivery rpcDelivery) internal void __endSendClientRpc(ref FastBufferWriter bufferWriter, uint rpcMethodId, ClientRpcParams clientRpcParams, RpcDelivery rpcDelivery)
#pragma warning restore IDE1006 // restore naming rule violation check #pragma warning restore IDE1006 // restore naming rule violation check
{ {
var networkManager = NetworkManager;
var clientRpcMessage = new ClientRpcMessage var clientRpcMessage = new ClientRpcMessage
{ {
Metadata = new RpcMetadata Metadata = new RpcMetadata
@@ -168,7 +170,7 @@ namespace Unity.Netcode
networkDelivery = NetworkDelivery.ReliableFragmentedSequenced; networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
break; break;
case RpcDelivery.Unreliable: case RpcDelivery.Unreliable:
if (bufferWriter.Length > NetworkManager.MessageManager.NonFragmentedMessageMaxSize) if (bufferWriter.Length > networkManager.MessageManager.NonFragmentedMessageMaxSize)
{ {
throw new OverflowException("RPC parameters are too large for unreliable delivery."); throw new OverflowException("RPC parameters are too large for unreliable delivery.");
} }
@@ -180,24 +182,22 @@ namespace Unity.Netcode
// We check to see if we need to shortcut for the case where we are the host/server and we can send a clientRPC // We check to see if we need to shortcut for the case where we are the host/server and we can send a clientRPC
// to ourself. Sadly we have to figure that out from the list of clientIds :( // to ourself. Sadly we have to figure that out from the list of clientIds :(
bool shouldSendToHost = false; bool shouldInvokeLocally = false;
if (clientRpcParams.Send.TargetClientIds != null) if (clientRpcParams.Send.TargetClientIds != null)
{ {
foreach (var targetClientId in clientRpcParams.Send.TargetClientIds) foreach (var targetClientId in clientRpcParams.Send.TargetClientIds)
{ {
if (targetClientId == NetworkManager.ServerClientId) if (targetClientId == NetworkManager.ServerClientId)
{ {
shouldSendToHost = true; shouldInvokeLocally = true;
break; continue;
} }
// Check to make sure we are sending to only observers, if not log an error. // Check to make sure we are sending to only observers, if not log an error.
if (NetworkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId)) if (networkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId))
{ {
NetworkLog.LogError(GenerateObserverErrorMessage(clientRpcParams, targetClientId)); NetworkLog.LogError(GenerateObserverErrorMessage(clientRpcParams, targetClientId));
} }
} }
rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, in clientRpcParams.Send.TargetClientIds); rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, in clientRpcParams.Send.TargetClientIds);
} }
else if (clientRpcParams.Send.TargetClientIdsNativeArray != null) else if (clientRpcParams.Send.TargetClientIdsNativeArray != null)
@@ -206,17 +206,15 @@ namespace Unity.Netcode
{ {
if (targetClientId == NetworkManager.ServerClientId) if (targetClientId == NetworkManager.ServerClientId)
{ {
shouldSendToHost = true; shouldInvokeLocally = true;
break; continue;
} }
// Check to make sure we are sending to only observers, if not log an error. // Check to make sure we are sending to only observers, if not log an error.
if (NetworkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId)) if (networkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId))
{ {
NetworkLog.LogError(GenerateObserverErrorMessage(clientRpcParams, targetClientId)); NetworkLog.LogError(GenerateObserverErrorMessage(clientRpcParams, targetClientId));
} }
} }
rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, clientRpcParams.Send.TargetClientIdsNativeArray.Value); rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, clientRpcParams.Send.TargetClientIdsNativeArray.Value);
} }
else else
@@ -227,7 +225,7 @@ namespace Unity.Netcode
// Skip over the host // Skip over the host
if (IsHost && observerEnumerator.Current == NetworkManager.LocalClientId) if (IsHost && observerEnumerator.Current == NetworkManager.LocalClientId)
{ {
shouldSendToHost = true; shouldInvokeLocally = true;
continue; continue;
} }
rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, observerEnumerator.Current); rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, observerEnumerator.Current);
@@ -235,14 +233,14 @@ namespace Unity.Netcode
} }
// If we are a server/host then we just no op and send to ourself // If we are a server/host then we just no op and send to ourself
if (shouldSendToHost) if (shouldInvokeLocally)
{ {
using var tempBuffer = new FastBufferReader(bufferWriter, Allocator.Temp); using var tempBuffer = new FastBufferReader(bufferWriter, Allocator.Temp);
var context = new NetworkContext var context = new NetworkContext
{ {
SenderId = NetworkManager.ServerClientId, SenderId = NetworkManager.ServerClientId,
Timestamp = NetworkManager.RealTimeProvider.RealTimeSinceStartup, Timestamp = networkManager.RealTimeProvider.RealTimeSinceStartup,
SystemOwner = NetworkManager, SystemOwner = networkManager,
// header information isn't valid since it's not a real message. // header information isn't valid since it's not a real message.
// RpcMessage doesn't access this stuff so it's just left empty. // RpcMessage doesn't access this stuff so it's just left empty.
Header = new NetworkMessageHeader(), Header = new NetworkMessageHeader(),
@@ -261,7 +259,7 @@ namespace Unity.Netcode
{ {
foreach (var targetClientId in clientRpcParams.Send.TargetClientIds) foreach (var targetClientId in clientRpcParams.Send.TargetClientIds)
{ {
NetworkManager.NetworkMetrics.TrackRpcSent( networkManager.NetworkMetrics.TrackRpcSent(
targetClientId, targetClientId,
NetworkObject, NetworkObject,
rpcMethodName, rpcMethodName,
@@ -273,7 +271,7 @@ namespace Unity.Netcode
{ {
foreach (var targetClientId in clientRpcParams.Send.TargetClientIdsNativeArray) foreach (var targetClientId in clientRpcParams.Send.TargetClientIdsNativeArray)
{ {
NetworkManager.NetworkMetrics.TrackRpcSent( networkManager.NetworkMetrics.TrackRpcSent(
targetClientId, targetClientId,
NetworkObject, NetworkObject,
rpcMethodName, rpcMethodName,
@@ -286,7 +284,7 @@ namespace Unity.Netcode
var observerEnumerator = NetworkObject.Observers.GetEnumerator(); var observerEnumerator = NetworkObject.Observers.GetEnumerator();
while (observerEnumerator.MoveNext()) while (observerEnumerator.MoveNext())
{ {
NetworkManager.NetworkMetrics.TrackRpcSent( networkManager.NetworkMetrics.TrackRpcSent(
observerEnumerator.Current, observerEnumerator.Current,
NetworkObject, NetworkObject,
rpcMethodName, rpcMethodName,
@@ -372,6 +370,12 @@ namespace Unity.Netcode
case SendTo.ClientsAndHost: case SendTo.ClientsAndHost:
rpcParams.Send.Target = RpcTarget.ClientsAndHost; rpcParams.Send.Target = RpcTarget.ClientsAndHost;
break; break;
case SendTo.Authority:
rpcParams.Send.Target = RpcTarget.Authority;
break;
case SendTo.NotAuthority:
rpcParams.Send.Target = RpcTarget.NotAuthority;
break;
case SendTo.SpecifiedInParams: case SendTo.SpecifiedInParams:
throw new RpcException("This method requires a runtime-specified send target."); throw new RpcException("This method requires a runtime-specified send target.");
} }
@@ -456,6 +460,31 @@ namespace Unity.Netcode
/// </summary> /// </summary>
public bool IsServer { get; private set; } public bool IsServer { get; private set; }
/// <summary>
/// Determines if the local client has authority over the associated NetworkObject
/// Client-Server: This will return true if IsServer or IsHost
/// Distributed Authority: This will return true if IsOwner
/// </summary>
public bool HasAuthority { get; internal set; }
internal NetworkClient LocalClient { get; private set; }
/// <summary>
/// Gets if the client is the distributed authority mode session owner
/// </summary>
public bool IsSessionOwner
{
get
{
if (LocalClient == null)
{
return false;
}
return LocalClient.IsSessionOwner;
}
}
/// <summary> /// <summary>
/// Gets if the server (local or remote) is a host - i.e., also a client /// Gets if the server (local or remote) is a host - i.e., also a client
/// </summary> /// </summary>
@@ -505,12 +534,14 @@ namespace Unity.Netcode
{ {
get get
{ {
if (m_NetworkObject != null)
{
return m_NetworkObject;
}
try try
{ {
if (m_NetworkObject == null) m_NetworkObject = GetComponentInParent<NetworkObject>();
{
m_NetworkObject = GetComponentInParent<NetworkObject>();
}
} }
catch (Exception) catch (Exception)
{ {
@@ -579,30 +610,34 @@ namespace Unity.Netcode
/// </summary> /// </summary>
internal void UpdateNetworkProperties() internal void UpdateNetworkProperties()
{ {
var networkObject = NetworkObject;
// Set NetworkObject dependent properties // Set NetworkObject dependent properties
if (NetworkObject != null) if (networkObject != null)
{ {
var networkManager = NetworkManager;
// Set identification related properties // Set identification related properties
NetworkObjectId = NetworkObject.NetworkObjectId; NetworkObjectId = networkObject.NetworkObjectId;
IsLocalPlayer = NetworkObject.IsLocalPlayer; IsLocalPlayer = networkObject.IsLocalPlayer;
// This is "OK" because GetNetworkBehaviourOrderIndex uses the order of // This is "OK" because GetNetworkBehaviourOrderIndex uses the order of
// NetworkObject.ChildNetworkBehaviours which is set once when first // NetworkObject.ChildNetworkBehaviours which is set once when first
// accessed. // accessed.
NetworkBehaviourId = NetworkObject.GetNetworkBehaviourOrderIndex(this); NetworkBehaviourId = networkObject.GetNetworkBehaviourOrderIndex(this);
// Set ownership related properties // Set ownership related properties
IsOwnedByServer = NetworkObject.IsOwnedByServer; IsOwnedByServer = networkObject.IsOwnedByServer;
IsOwner = NetworkObject.IsOwner; IsOwner = networkObject.IsOwner;
OwnerClientId = NetworkObject.OwnerClientId; OwnerClientId = networkObject.OwnerClientId;
// Set NetworkManager dependent properties // Set NetworkManager dependent properties
if (NetworkManager != null) if (networkManager != null)
{ {
IsHost = NetworkManager.IsListening && NetworkManager.IsHost; IsHost = networkManager.IsListening && networkManager.IsHost;
IsClient = NetworkManager.IsListening && NetworkManager.IsClient; IsClient = networkManager.IsListening && networkManager.IsClient;
IsServer = NetworkManager.IsListening && NetworkManager.IsServer; IsServer = networkManager.IsListening && networkManager.IsServer;
ServerIsHost = NetworkManager.IsListening && NetworkManager.ServerIsHost; LocalClient = networkManager.LocalClient;
HasAuthority = networkObject.HasAuthority;
ServerIsHost = networkManager.IsListening && networkManager.ServerIsHost;
} }
} }
else // Shouldn't happen, but if so then set the properties to their default value; else // Shouldn't happen, but if so then set the properties to their default value;
@@ -610,9 +645,21 @@ namespace Unity.Netcode
OwnerClientId = NetworkObjectId = default; OwnerClientId = NetworkObjectId = default;
IsOwnedByServer = IsOwner = IsHost = IsClient = IsServer = ServerIsHost = default; IsOwnedByServer = IsOwner = IsHost = IsClient = IsServer = ServerIsHost = default;
NetworkBehaviourId = default; NetworkBehaviourId = default;
LocalClient = default;
HasAuthority = default;
} }
} }
/// <summary>
/// Distributed Authority Mode Only
/// Invoked only on the authority instance when a <see cref="NetworkObject"/> is deferring its despawn on non-authoritative instances.
/// </summary>
/// <remarks>
/// See also: <see cref="NetworkObject.DeferDespawn(int, bool)"/>
/// </remarks>
/// <param name="despawnTick">the future network tick that the <see cref="NetworkObject"/> will be despawned on non-authoritative instances</param>
public virtual void OnDeferringDespawn(int despawnTick) { }
/// <summary> /// <summary>
/// Gets called when the <see cref="NetworkObject"/> gets spawned, message handlers are ready to be registered and the network is setup. /// Gets called when the <see cref="NetworkObject"/> gets spawned, message handlers are ready to be registered and the network is setup.
/// </summary> /// </summary>
@@ -642,7 +689,8 @@ namespace Unity.Netcode
} }
InitializeVariables(); InitializeVariables();
if (IsServer)
if (NetworkObject.HasAuthority)
{ {
// Since we just spawned the object and since user code might have modified their NetworkVariable, esp. // Since we just spawned the object and since user code might have modified their NetworkVariable, esp.
// NetworkList, we need to mark the object as free of updates. // NetworkList, we need to mark the object as free of updates.
@@ -679,7 +727,7 @@ namespace Unity.Netcode
/// <summary> /// <summary>
/// Invoked on all clients, override this method to be notified of any /// Invoked on all clients, override this method to be notified of any
/// ownership changes (even if the instance was niether the previous or /// ownership changes (even if the instance was niether the previous or
/// newly assigned current owner). /// newly assigned current owner).
/// </summary> /// </summary>
/// <param name="previous">the previous owner</param> /// <param name="previous">the previous owner</param>
/// <param name="current">the current owner</param> /// <param name="current">the current owner</param>
@@ -838,65 +886,83 @@ namespace Unity.Netcode
PreNetworkVariableWrite(); PreNetworkVariableWrite();
} }
internal void VariableUpdate(ulong targetClientId)
{
NetworkVariableUpdate(targetClientId, NetworkBehaviourId);
}
internal readonly List<int> NetworkVariableIndexesToReset = new List<int>(); internal readonly List<int> NetworkVariableIndexesToReset = new List<int>();
internal readonly HashSet<int> NetworkVariableIndexesToResetSet = new HashSet<int>(); internal readonly HashSet<int> NetworkVariableIndexesToResetSet = new HashSet<int>();
private void NetworkVariableUpdate(ulong targetClientId, int behaviourIndex) internal void NetworkVariableUpdate(ulong targetClientId)
{ {
if (!CouldHaveDirtyNetworkVariables()) if (!CouldHaveDirtyNetworkVariables())
{ {
return; return;
} }
// Getting these ahead of time actually improves performance
var networkManager = NetworkManager;
var networkObject = NetworkObject;
var behaviourIndex = networkObject.GetNetworkBehaviourOrderIndex(this);
var messageManager = networkManager.MessageManager;
var connectionManager = networkManager.ConnectionManager;
for (int j = 0; j < m_DeliveryMappedNetworkVariableIndices.Count; j++) for (int j = 0; j < m_DeliveryMappedNetworkVariableIndices.Count; j++)
{ {
var networkVariable = (NetworkVariableBase)null;
var shouldSend = false; var shouldSend = false;
for (int k = 0; k < NetworkVariableFields.Count; k++) for (int k = 0; k < NetworkVariableFields.Count; k++)
{ {
var networkVariable = NetworkVariableFields[k]; networkVariable = NetworkVariableFields[k];
if (networkVariable.IsDirty() && networkVariable.CanClientRead(targetClientId)) if (networkVariable.IsDirty() && networkVariable.CanClientRead(targetClientId))
{ {
shouldSend = true; shouldSend = true;
break; break;
} }
} }
// All of this is just to prevent the DA Host from re-sending a NetworkVariable update it received from the client owner
if (shouldSend) // If this NetworkManager is running as a DAHost:
// - Only when the write permissions is owner (to pass existing integration tests running as DAHost)
// - If the target client ID is the owner and the owner is not the local NetworkManager instance
// - **Special** As long as ownership did not just change and we are sending the new owner any dirty/updated NetworkVariables
// Under these conditions we should not send to the client
if (shouldSend && networkManager.DAHost && networkVariable.WritePerm == NetworkVariableWritePermission.Owner &&
networkObject.OwnerClientId == targetClientId && networkObject.OwnerClientId != networkManager.LocalClientId &&
networkObject.PreviousOwnerId == networkObject.OwnerClientId)
{ {
var message = new NetworkVariableDeltaMessage shouldSend = false;
}
if (!shouldSend)
{
continue;
}
var message = new NetworkVariableDeltaMessage
{
NetworkObjectId = NetworkObjectId,
NetworkBehaviourIndex = behaviourIndex,
NetworkBehaviour = this,
TargetClientId = targetClientId,
DeliveryMappedNetworkVariableIndex = m_DeliveryMappedNetworkVariableIndices[j]
};
// TODO: Serialization is where the IsDirty flag gets changed.
// Messages don't get sent from the server to itself, so if we're host and sending to ourselves,
// we still have to actually serialize the message even though we're not sending it, otherwise
// the dirty flag doesn't change properly. These two pieces should be decoupled at some point
// so we don't have to do this serialization work if we're not going to use the result.
if (IsServer && targetClientId == NetworkManager.ServerClientId)
{
var tmpWriter = new FastBufferWriter(messageManager.NonFragmentedMessageMaxSize, Allocator.Temp, messageManager.FragmentedMessageMaxSize);
using (tmpWriter)
{ {
NetworkObjectId = NetworkObjectId, message.Serialize(tmpWriter, message.Version);
NetworkBehaviourIndex = NetworkObject.GetNetworkBehaviourOrderIndex(this),
NetworkBehaviour = this,
TargetClientId = targetClientId,
DeliveryMappedNetworkVariableIndex = m_DeliveryMappedNetworkVariableIndices[j]
};
// TODO: Serialization is where the IsDirty flag gets changed.
// Messages don't get sent from the server to itself, so if we're host and sending to ourselves,
// we still have to actually serialize the message even though we're not sending it, otherwise
// the dirty flag doesn't change properly. These two pieces should be decoupled at some point
// so we don't have to do this serialization work if we're not going to use the result.
if (IsServer && targetClientId == NetworkManager.ServerClientId)
{
var tmpWriter = new FastBufferWriter(NetworkManager.MessageManager.NonFragmentedMessageMaxSize, Allocator.Temp, NetworkManager.MessageManager.FragmentedMessageMaxSize);
using (tmpWriter)
{
message.Serialize(tmpWriter, message.Version);
}
}
else
{
NetworkManager.ConnectionManager.SendMessage(ref message, m_DeliveryTypesForNetworkVariableGroups[j], targetClientId);
} }
} }
else
{
connectionManager.SendMessage(ref message, m_DeliveryTypesForNetworkVariableGroups[j], targetClientId);
}
} }
} }
internal static bool LogSentVariableUpdateMessage;
private bool CouldHaveDirtyNetworkVariables() private bool CouldHaveDirtyNetworkVariables()
{ {
// TODO: There should be a better way by reading one dirty variable vs. 'n' // TODO: There should be a better way by reading one dirty variable vs. 'n'
@@ -929,17 +995,30 @@ namespace Unity.Netcode
/// </remarks> /// </remarks>
internal void WriteNetworkVariableData(FastBufferWriter writer, ulong targetClientId) internal void WriteNetworkVariableData(FastBufferWriter writer, ulong targetClientId)
{ {
var networkManager = NetworkManager;
if (networkManager.DistributedAuthorityMode)
{
writer.WriteValueSafe((ushort)NetworkVariableFields.Count);
}
if (NetworkVariableFields.Count == 0) if (NetworkVariableFields.Count == 0)
{ {
return; return;
} }
// DANGO-TODO: Made some modifications here that overlap/won't play nice with EnsureNetworkVariableLenghtSafety.
// Worth either merging or more cleanly separating these codepaths.
for (int j = 0; j < NetworkVariableFields.Count; j++) for (int j = 0; j < NetworkVariableFields.Count; j++)
{ {
// Note: In distributed authority mode, all clients can read
if (NetworkVariableFields[j].CanClientRead(targetClientId)) if (NetworkVariableFields[j].CanClientRead(targetClientId))
{ {
if (NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety) if (networkManager.DistributedAuthorityMode)
{
writer.WriteValueSafe(NetworkVariableFields[j].Type);
}
if (networkManager.DistributedAuthorityMode || networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
{ {
var writePos = writer.Position; var writePos = writer.Position;
// Note: This value can't be packed because we don't know how large it will be in advance // Note: This value can't be packed because we don't know how large it will be in advance
@@ -960,10 +1039,13 @@ namespace Unity.Netcode
NetworkVariableFields[j].WriteField(writer); NetworkVariableFields[j].WriteField(writer);
} }
} }
else // Only if EnsureNetworkVariableLengthSafety, otherwise just skip else
if (NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
{ {
writer.WriteValueSafe((ushort)0); // Only if EnsureNetworkVariableLengthSafety, otherwise just skip
if (networkManager.DistributedAuthorityMode || networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
{
writer.WriteValueSafe((ushort)0);
}
} }
} }
} }
@@ -978,16 +1060,29 @@ namespace Unity.Netcode
/// </remarks> /// </remarks>
internal void SetNetworkVariableData(FastBufferReader reader, ulong clientId) internal void SetNetworkVariableData(FastBufferReader reader, ulong clientId)
{ {
var networkManager = NetworkManager;
if (networkManager.DistributedAuthorityMode)
{
reader.ReadValueSafe(out ushort variableCount);
if (variableCount != NetworkVariableFields.Count)
{
Debug.LogError("NetworkVariable count mismatch.");
return;
}
}
if (NetworkVariableFields.Count == 0) if (NetworkVariableFields.Count == 0)
{ {
return; return;
} }
// DANGO-TODO: Made some modifications here that overlap/won't play nice with EnsureNetworkVariableLenghtSafety.
// Worth either merging or more cleanly separating these codepaths.
for (int j = 0; j < NetworkVariableFields.Count; j++) for (int j = 0; j < NetworkVariableFields.Count; j++)
{ {
var varSize = (ushort)0; var varSize = (ushort)0;
var readStartPos = 0; var readStartPos = 0;
if (NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety) if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
{ {
reader.ReadValueSafe(out varSize); reader.ReadValueSafe(out varSize);
if (varSize == 0) if (varSize == 0)
@@ -999,12 +1094,35 @@ namespace Unity.Netcode
else // If the client cannot read this field, then skip it else // If the client cannot read this field, then skip it
if (!NetworkVariableFields[j].CanClientRead(clientId)) if (!NetworkVariableFields[j].CanClientRead(clientId))
{ {
if (networkManager.DistributedAuthorityMode)
{
reader.ReadValueSafe(out ushort size);
if (size != 0)
{
Debug.LogError("Expected zero size");
}
}
continue; continue;
} }
NetworkVariableFields[j].ReadField(reader); if (networkManager.DistributedAuthorityMode)
{
// Explicit setting of the NetworkVariableType is only needed for CMB Runtime
reader.ReadValueSafe(out NetworkVariableType _);
reader.ReadValueSafe(out ushort size);
var start_marker = reader.Position;
NetworkVariableFields[j].ReadField(reader);
if (reader.Position - start_marker != size)
{
Debug.LogError("Mismatched network variable size");
}
}
else
{
NetworkVariableFields[j].ReadField(reader);
}
if (NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety) if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
{ {
if (reader.Position > (readStartPos + varSize)) if (reader.Position > (readStartPos + varSize))
{ {
@@ -1170,7 +1288,7 @@ namespace Unity.Netcode
{ {
if (NetworkManager.LogLevel <= LogLevel.Normal) if (NetworkManager.LogLevel <= LogLevel.Normal)
{ {
NetworkLog.LogWarning($"{name} read {totalBytesRead} bytes but was expected to read {expectedBytesToRead} bytes during synchronization deserialization! This {nameof(NetworkBehaviour)} is being skipped and will not be synchronized!"); NetworkLog.LogWarning($"{name} read {totalBytesRead} bytes but was expected to read {expectedBytesToRead} bytes during synchronization deserialization! This {nameof(NetworkBehaviour)}({GetType().Name})is being skipped and will not be synchronized!");
} }
synchronizationError = true; synchronizationError = true;
} }

9
Runtime/Core/NetworkBehaviourUpdater.cs
View File

@@ -44,13 +44,12 @@ namespace Unity.Netcode
for (int i = 0; i < m_ConnectionManager.ConnectedClientsList.Count; i++) for (int i = 0; i < m_ConnectionManager.ConnectedClientsList.Count; i++)
{ {
var client = m_ConnectionManager.ConnectedClientsList[i]; var client = m_ConnectionManager.ConnectedClientsList[i];
if (m_NetworkManager.DistributedAuthorityMode || dirtyObj.IsNetworkVisibleTo(client.ClientId))
if (dirtyObj.IsNetworkVisibleTo(client.ClientId))
{ {
// Sync just the variables for just the objects this client sees // Sync just the variables for just the objects this client sees
for (int k = 0; k < dirtyObj.ChildNetworkBehaviours.Count; k++) for (int k = 0; k < dirtyObj.ChildNetworkBehaviours.Count; k++)
{ {
dirtyObj.ChildNetworkBehaviours[k].VariableUpdate(client.ClientId); dirtyObj.ChildNetworkBehaviours[k].NetworkVariableUpdate(client.ClientId);
} }
} }
} }
@@ -69,7 +68,7 @@ namespace Unity.Netcode
} }
for (int k = 0; k < sobj.ChildNetworkBehaviours.Count; k++) for (int k = 0; k < sobj.ChildNetworkBehaviours.Count; k++)
{ {
sobj.ChildNetworkBehaviours[k].VariableUpdate(NetworkManager.ServerClientId); sobj.ChildNetworkBehaviours[k].NetworkVariableUpdate(NetworkManager.ServerClientId);
} }
} }
} }
@@ -95,6 +94,8 @@ namespace Unity.Netcode
foreach (var dirtyobj in m_DirtyNetworkObjects) foreach (var dirtyobj in m_DirtyNetworkObjects)
{ {
dirtyobj.PostNetworkVariableWrite(); dirtyobj.PostNetworkVariableWrite();
// Once done processing, we set the previous owner id to the current owner id
dirtyobj.PreviousOwnerId = dirtyobj.OwnerClientId;
} }
m_DirtyNetworkObjects.Clear(); m_DirtyNetworkObjects.Clear();
} }

202
Runtime/Core/NetworkManager.cs
View File

@@ -1,6 +1,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using Unity.Collections; using Unity.Collections;
using System.Linq;
using UnityEngine; using UnityEngine;
#if UNITY_EDITOR #if UNITY_EDITOR
using UnityEditor; using UnityEditor;
@@ -34,6 +35,148 @@ namespace Unity.Netcode
#pragma warning restore IDE1006 // restore naming rule violation check #pragma warning restore IDE1006 // restore naming rule violation check
/// <summary>
/// Distributed Authority Mode
/// Returns true if the current session is running in distributed authority mode.
/// </summary>
public bool DistributedAuthorityMode
{
get
{
return NetworkConfig.SessionMode == SessionModeTypes.DistributedAuthority;
}
}
/// <summary>
/// Distributed Authority Mode
/// Gets whether the NetworkManager is connected to a distributed authority state service.
/// <see cref="NetworkClient.DAHost"/> to determine if the instance is mocking the state service.
/// </summary>
public bool CMBServiceConnection
{
get
{
return NetworkConfig.UseCMBService;
}
}
/// <summary>
/// Distributed Authority Mode
/// When enabled, the player prefab will be automatically spawned on the newly connected client-side.
/// </summary>
/// <remarks>
/// Refer to <see cref="NetworkConfig.AutoSpawnPlayerPrefabClientSide"/> to enable/disable automatic spawning of the player prefab.
/// Alternately, override the <see cref="FetchLocalPlayerPrefabToSpawn"/> to control what prefab the player should spawn.
/// </remarks>
public bool AutoSpawnPlayerPrefabClientSide
{
get
{
return NetworkConfig.AutoSpawnPlayerPrefabClientSide;
}
}
/// <summary>
/// Distributed Authority Mode
/// Delegate definition for <see cref="FetchLocalPlayerPrefabToSpawn"/>
/// </summary>
/// <returns>Player Prefab <see cref="GameObject"/></returns>
public delegate GameObject OnFetchLocalPlayerPrefabToSpawnDelegateHandler();
/// <summary>
/// Distributed Authority Mode
/// When a callback is assigned, this provides control over what player prefab a client will be using.
/// This is invoked only when <see cref="NetworkConfig.AutoSpawnPlayerPrefabClientSide"/> is enabled.
/// </summary>
public OnFetchLocalPlayerPrefabToSpawnDelegateHandler OnFetchLocalPlayerPrefabToSpawn;
internal GameObject FetchLocalPlayerPrefabToSpawn()
{
if (!AutoSpawnPlayerPrefabClientSide)
{
Debug.LogError($"[{nameof(FetchLocalPlayerPrefabToSpawn)}] Invoked when {nameof(NetworkConfig.AutoSpawnPlayerPrefabClientSide)} was not set! Check call paths!");
return null;
}
if (OnFetchLocalPlayerPrefabToSpawn == null && NetworkConfig.PlayerPrefab == null)
{
return null;
}
if (OnFetchLocalPlayerPrefabToSpawn != null)
{
return OnFetchLocalPlayerPrefabToSpawn();
}
return NetworkConfig.PlayerPrefab;
}
/// <summary>
/// Distributed Authority Mode
/// Gets whether the current NetworkManager is running as a mock distributed authority state service (DAHost)
/// </summary>
public bool DAHost
{
get
{
return LocalClient.DAHost;
}
}
// DANGO-TODO-MVP: Remove these properties once the service handles object distribution
internal ulong ClientToRedistribute;
internal bool RedistributeToClient;
internal int TickToRedistribute;
internal List<NetworkObject> DeferredDespawnObjects = new List<NetworkObject>();
public ulong CurrentSessionOwner { get; internal set; }
internal void SetSessionOwner(ulong sessionOwner)
{
var previousSessionOwner = CurrentSessionOwner;
CurrentSessionOwner = sessionOwner;
LocalClient.IsSessionOwner = LocalClientId == sessionOwner;
if (LocalClient.IsSessionOwner)
{
foreach (var networkObjectEntry in SpawnManager.SpawnedObjects)
{
var networkObject = networkObjectEntry.Value;
if (networkObject.IsSceneObject == null || !networkObject.IsSceneObject.Value)
{
continue;
}
if (networkObject.OwnerClientId != LocalClientId)
{
SpawnManager.ChangeOwnership(networkObject, LocalClientId, true);
}
}
}
}
// TODO: Make this internal after testing
public void PromoteSessionOwner(ulong clientId)
{
if (!DistributedAuthorityMode)
{
NetworkLog.LogErrorServer($"[SceneManagement][NotDA] Invoking promote session owner while not in distributed authority mode!");
return;
}
if (!DAHost)
{
NetworkLog.LogErrorServer($"[SceneManagement][NotDAHost] Client is attempting to promote another client as the session owner!");
return;
}
SetSessionOwner(clientId);
var sessionOwnerMessage = new SessionOwnerMessage()
{
SessionOwner = clientId,
};
var clients = ConnectionManager.ConnectedClientIds.Where(c => c != LocalClientId).ToArray();
foreach (var targetClient in clients)
{
ConnectionManager.SendMessage(ref sessionOwnerMessage, NetworkDelivery.ReliableSequenced, targetClient);
}
}
public void NetworkUpdate(NetworkUpdateStage updateStage) public void NetworkUpdate(NetworkUpdateStage updateStage)
{ {
switch (updateStage) switch (updateStage)
@@ -56,6 +199,15 @@ namespace Unity.Netcode
break; break;
case NetworkUpdateStage.PostLateUpdate: case NetworkUpdateStage.PostLateUpdate:
{ {
// Handle deferred despawning
if (DistributedAuthorityMode)
{
SpawnManager.DeferredDespawnUpdate(ServerTime);
}
// Update any NetworkObject's registered to notify of scene migration changes.
NetworkObject.UpdateNetworkObjectSceneChanges();
// This should be invoked just prior to the MessageManager processes its outbound queue. // This should be invoked just prior to the MessageManager processes its outbound queue.
SceneManager.CheckForAndSendNetworkObjectSceneChanged(); SceneManager.CheckForAndSendNetworkObjectSceneChanged();
@@ -71,6 +223,16 @@ namespace Unity.Netcode
// This is "ok" to invoke when not processing messages since it is just cleaning up messages that never got handled within their timeout period. // This is "ok" to invoke when not processing messages since it is just cleaning up messages that never got handled within their timeout period.
DeferredMessageManager.CleanupStaleTriggers(); DeferredMessageManager.CleanupStaleTriggers();
// DANGO-TODO-MVP: Remove this once the service handles object distribution
// NOTE: This needs to be the last thing done and should happen exactly at this point
// in the update
if (RedistributeToClient && ServerTime.Tick <= TickToRedistribute)
{
RedistributeToClient = false;
SpawnManager.DistributeNetworkObjects(ClientToRedistribute);
ClientToRedistribute = 0;
}
if (m_ShuttingDown) if (m_ShuttingDown)
{ {
// Host-server will disconnect any connected clients prior to finalizing its shutdown // Host-server will disconnect any connected clients prior to finalizing its shutdown
@@ -171,17 +333,17 @@ namespace Unity.Netcode
} }
/// <summary> /// <summary>
/// Gets a dictionary of connected clients and their clientId keys. This is only accessible on the server. /// Gets a dictionary of connected clients and their clientId keys.
/// </summary> /// </summary>
public IReadOnlyDictionary<ulong, NetworkClient> ConnectedClients => IsServer ? ConnectionManager.ConnectedClients : throw new NotServerException($"{nameof(ConnectionManager.ConnectedClients)} should only be accessed on server."); public IReadOnlyDictionary<ulong, NetworkClient> ConnectedClients => ConnectionManager.ConnectedClients;
/// <summary> /// <summary>
/// Gets a list of connected clients. This is only accessible on the server. /// Gets a list of connected clients.
/// </summary> /// </summary>
public IReadOnlyList<NetworkClient> ConnectedClientsList => IsServer ? ConnectionManager.ConnectedClientsList : throw new NotServerException($"{nameof(ConnectionManager.ConnectedClientsList)} should only be accessed on server."); public IReadOnlyList<NetworkClient> ConnectedClientsList => ConnectionManager.ConnectedClientsList;
/// <summary> /// <summary>
/// Gets a list of just the IDs of all connected clients. This is only accessible on the server. /// Gets a list of just the IDs of all connected clients.
/// </summary> /// </summary>
public IReadOnlyList<ulong> ConnectedClientsIds => ConnectionManager.ConnectedClientIds; public IReadOnlyList<ulong> ConnectedClientsIds => ConnectionManager.ConnectedClientIds;
@@ -780,6 +942,10 @@ namespace Unity.Netcode
internal void Initialize(bool server) internal void Initialize(bool server)
{ {
//DANGOEXP TODO: Remove this before finalizing the experimental release
NetworkConfig.AutoSpawnPlayerPrefabClientSide = DistributedAuthorityMode;
// Make sure the ServerShutdownState is reset when initializing // Make sure the ServerShutdownState is reset when initializing
if (server) if (server)
{ {
@@ -930,7 +1096,10 @@ namespace Unity.Netcode
return false; return false;
} }
ConnectionManager.LocalClient.SetRole(true, false, this); if (!ConnectionManager.LocalClient.SetRole(true, false, this))
{
return false;
}
ConnectionManager.LocalClient.ClientId = ServerClientId; ConnectionManager.LocalClient.ClientId = ServerClientId;
Initialize(true); Initialize(true);
@@ -976,7 +1145,10 @@ namespace Unity.Netcode
return false; return false;
} }
ConnectionManager.LocalClient.SetRole(false, true, this); if (!ConnectionManager.LocalClient.SetRole(false, true, this))
{
return false;
}
Initialize(false); Initialize(false);
@@ -1019,7 +1191,11 @@ namespace Unity.Netcode
return false; return false;
} }
ConnectionManager.LocalClient.SetRole(true, true, this); if (!ConnectionManager.LocalClient.SetRole(true, true, this))
{
return false;
}
Initialize(true); Initialize(true);
try try
{ {
@@ -1075,7 +1251,8 @@ namespace Unity.Netcode
var response = new ConnectionApprovalResponse var response = new ConnectionApprovalResponse
{ {
Approved = true, Approved = true,
CreatePlayerObject = NetworkConfig.PlayerPrefab != null // Distributed authority always returns true since the client side handles spawning (whether automatically or manually)
CreatePlayerObject = DistributedAuthorityMode || NetworkConfig.PlayerPrefab != null,
}; };
ConnectionManager.HandleConnectionApproval(ServerClientId, response); ConnectionManager.HandleConnectionApproval(ServerClientId, response);
} }
@@ -1185,6 +1362,12 @@ namespace Unity.Netcode
IsListening = false; IsListening = false;
m_ShuttingDown = false; m_ShuttingDown = false;
// Generate a local notification that the host client is disconnected
if (IsHost)
{
ConnectionManager.InvokeOnClientDisconnectCallback(LocalClientId);
}
if (ConnectionManager.LocalClient.IsClient) if (ConnectionManager.LocalClient.IsClient)
{ {
// If we were a client, we want to know if we were a host // If we were a client, we want to know if we were a host
@@ -1218,6 +1401,7 @@ namespace Unity.Netcode
NetworkTickSystem = null; NetworkTickSystem = null;
} }
// Ensures that the NetworkManager is cleaned up before OnDestroy is run on NetworkObjects and NetworkBehaviours when quitting the application. // Ensures that the NetworkManager is cleaned up before OnDestroy is run on NetworkObjects and NetworkBehaviours when quitting the application.
private void OnApplicationQuit() private void OnApplicationQuit()
{ {

1359
Runtime/Core/NetworkObject.cs
View File

File diff suppressed because it is too large Load Diff

28
Runtime/Logging/NetworkLog.cs
View File

@@ -39,6 +39,12 @@ namespace Unity.Netcode
/// <param name="message">The message to log</param> /// <param name="message">The message to log</param>
public static void LogInfoServer(string message) => LogServer(message, LogType.Info); public static void LogInfoServer(string message) => LogServer(message, LogType.Info);
/// <summary>
/// Logs an info log locally and on the session owner if possible.
/// </summary>
/// <param name="message">The message to log</param>
public static void LogInfoSessionOwner(string message) => LogServer(message, LogType.Info);
/// <summary> /// <summary>
/// Logs a warning log locally and on the server if possible. /// Logs a warning log locally and on the server if possible.
/// </summary> /// </summary>
@@ -58,7 +64,8 @@ namespace Unity.Netcode
var networkManager = NetworkManagerOverride ??= NetworkManager.Singleton; var networkManager = NetworkManagerOverride ??= NetworkManager.Singleton;
// Get the sender of the local log // Get the sender of the local log
ulong localId = networkManager?.LocalClientId ?? 0; ulong localId = networkManager?.LocalClientId ?? 0;
bool isServer = networkManager?.IsServer ?? true; bool isServer = networkManager && networkManager.DistributedAuthorityMode ? networkManager.LocalClient.IsSessionOwner :
networkManager && !networkManager.DistributedAuthorityMode ? networkManager.IsServer : true;
switch (logType) switch (logType)
{ {
case LogType.Info: case LogType.Info:
@@ -98,7 +105,8 @@ namespace Unity.Netcode
var networkMessage = new ServerLogMessage var networkMessage = new ServerLogMessage
{ {
LogType = logType, LogType = logType,
Message = message Message = message,
SenderId = localId
}; };
var size = networkManager.ConnectionManager.SendMessage(ref networkMessage, NetworkDelivery.ReliableFragmentedSequenced, NetworkManager.ServerClientId); var size = networkManager.ConnectionManager.SendMessage(ref networkMessage, NetworkDelivery.ReliableFragmentedSequenced, NetworkManager.ServerClientId);
@@ -106,9 +114,19 @@ namespace Unity.Netcode
} }
} }
internal static void LogInfoServerLocal(string message, ulong sender) => Debug.Log($"[Netcode-Server Sender={sender}] {message}"); private static string Header()
internal static void LogWarningServerLocal(string message, ulong sender) => Debug.LogWarning($"[Netcode-Server Sender={sender}] {message}"); {
internal static void LogErrorServerLocal(string message, ulong sender) => Debug.LogError($"[Netcode-Server Sender={sender}] {message}"); var networkManager = NetworkManagerOverride ??= NetworkManager.Singleton;
if (networkManager.DistributedAuthorityMode)
{
return "Session-Owner";
}
return "Netcode-Server";
}
internal static void LogInfoServerLocal(string message, ulong sender) => Debug.Log($"[{Header()} Sender={sender}] {message}");
internal static void LogWarningServerLocal(string message, ulong sender) => Debug.LogWarning($"[{Header()} Sender={sender}] {message}");
internal static void LogErrorServerLocal(string message, ulong sender) => Debug.LogError($"[{Header()} Sender={sender}] {message}");
internal enum LogType : byte internal enum LogType : byte
{ {

34
Runtime/Messaging/CustomMessageManager.cs
View File

@@ -1,6 +1,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using Unity.Collections; using Unity.Collections;
using UnityEngine;
namespace Unity.Netcode namespace Unity.Netcode
{ {
@@ -151,18 +152,14 @@ namespace Unity.Netcode
// We dont know what size to use. Try every (more collision prone) // We dont know what size to use. Try every (more collision prone)
if (m_NamedMessageHandlers32.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler32)) if (m_NamedMessageHandlers32.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler32))
{ {
// handler can remove itself, cache the name for metrics
string messageName = m_MessageHandlerNameLookup32[hash];
messageHandler32(sender, reader); messageHandler32(sender, reader);
m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount); m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup32[hash], bytesCount);
} }
if (m_NamedMessageHandlers64.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler64)) if (m_NamedMessageHandlers64.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler64))
{ {
// handler can remove itself, cache the name for metrics
string messageName = m_MessageHandlerNameLookup64[hash];
messageHandler64(sender, reader); messageHandler64(sender, reader);
m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount); m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup64[hash], bytesCount);
} }
} }
else else
@@ -173,19 +170,15 @@ namespace Unity.Netcode
case HashSize.VarIntFourBytes: case HashSize.VarIntFourBytes:
if (m_NamedMessageHandlers32.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler32)) if (m_NamedMessageHandlers32.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler32))
{ {
// handler can remove itself, cache the name for metrics
string messageName = m_MessageHandlerNameLookup32[hash];
messageHandler32(sender, reader); messageHandler32(sender, reader);
m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount); m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup32[hash], bytesCount);
} }
break; break;
case HashSize.VarIntEightBytes: case HashSize.VarIntEightBytes:
if (m_NamedMessageHandlers64.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler64)) if (m_NamedMessageHandlers64.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler64))
{ {
// handler can remove itself, cache the name for metrics
string messageName = m_MessageHandlerNameLookup64[hash];
messageHandler64(sender, reader); messageHandler64(sender, reader);
m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount); m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup64[hash], bytesCount);
} }
break; break;
} }
@@ -199,6 +192,14 @@ namespace Unity.Netcode
/// <param name="callback">The callback to run when a named message is received.</param> /// <param name="callback">The callback to run when a named message is received.</param>
public void RegisterNamedMessageHandler(string name, HandleNamedMessageDelegate callback) public void RegisterNamedMessageHandler(string name, HandleNamedMessageDelegate callback)
{ {
if (string.IsNullOrEmpty(name))
{
if (m_NetworkManager.LogLevel <= LogLevel.Error)
{
Debug.LogError($"[{nameof(RegisterNamedMessageHandler)}] Cannot register a named message of type null or empty!");
}
return;
}
var hash32 = XXHash.Hash32(name); var hash32 = XXHash.Hash32(name);
var hash64 = XXHash.Hash64(name); var hash64 = XXHash.Hash64(name);
@@ -215,6 +216,15 @@ namespace Unity.Netcode
/// <param name="name">The name of the message.</param> /// <param name="name">The name of the message.</param>
public void UnregisterNamedMessageHandler(string name) public void UnregisterNamedMessageHandler(string name)
{ {
if (string.IsNullOrEmpty(name))
{
if (m_NetworkManager.LogLevel <= LogLevel.Error)
{
Debug.LogError($"[{nameof(UnregisterNamedMessageHandler)}] Cannot unregister a named message of type null or empty!");
}
return;
}
var hash32 = XXHash.Hash32(name); var hash32 = XXHash.Hash32(name);
var hash64 = XXHash.Hash64(name); var hash64 = XXHash.Hash64(name);

26
Runtime/Messaging/DeferredMessageManager.cs
View File

@@ -15,6 +15,7 @@ namespace Unity.Netcode
} }
protected struct TriggerInfo protected struct TriggerInfo
{ {
public string MessageType;
public float Expiry; public float Expiry;
public NativeList<TriggerData> TriggerData; public NativeList<TriggerData> TriggerData;
} }
@@ -36,7 +37,7 @@ namespace Unity.Netcode
/// There is a one second maximum lifetime of triggers to avoid memory leaks. After one second has passed /// There is a one second maximum lifetime of triggers to avoid memory leaks. After one second has passed
/// without the requested object ID being spawned, the triggers for it are automatically deleted. /// without the requested object ID being spawned, the triggers for it are automatically deleted.
/// </summary> /// </summary>
public virtual unsafe void DeferMessage(IDeferredNetworkMessageManager.TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context) public virtual unsafe void DeferMessage(IDeferredNetworkMessageManager.TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context, string messageType)
{ {
if (!m_Triggers.TryGetValue(trigger, out var triggers)) if (!m_Triggers.TryGetValue(trigger, out var triggers))
{ {
@@ -48,6 +49,7 @@ namespace Unity.Netcode
{ {
triggerInfo = new TriggerInfo triggerInfo = new TriggerInfo
{ {
MessageType = messageType,
Expiry = m_NetworkManager.RealTimeProvider.RealTimeSinceStartup + m_NetworkManager.NetworkConfig.SpawnTimeout, Expiry = m_NetworkManager.RealTimeProvider.RealTimeSinceStartup + m_NetworkManager.NetworkConfig.SpawnTimeout,
TriggerData = new NativeList<TriggerData>(Allocator.Persistent) TriggerData = new NativeList<TriggerData>(Allocator.Persistent)
}; };
@@ -90,11 +92,29 @@ namespace Unity.Netcode
} }
} }
/// <summary>
/// Used for testing purposes
/// </summary>
internal static bool IncludeMessageType = true;
private string GetWarningMessage(IDeferredNetworkMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo, float spawnTimeout)
{
if (IncludeMessageType)
{
return $"[Deferred {triggerType}] Messages were received for a trigger of type {triggerInfo.MessageType} associated with id ({key}), but the {nameof(NetworkObject)} was not received within the timeout period {spawnTimeout} second(s).";
}
else
{
return $"Deferred messages were received for a trigger of type {triggerType} associated with id ({key}), but the {nameof(NetworkObject)} was not received within the timeout period {spawnTimeout} second(s).";
}
}
protected virtual void PurgeTrigger(IDeferredNetworkMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo) protected virtual void PurgeTrigger(IDeferredNetworkMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo)
{ {
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal) var logLevel = m_NetworkManager.DistributedAuthorityMode ? LogLevel.Developer : LogLevel.Normal;
if (NetworkLog.CurrentLogLevel <= logLevel)
{ {
NetworkLog.LogWarning($"Deferred messages were received for a trigger of type {triggerType} with key {key}, but that trigger was not received within within {m_NetworkManager.NetworkConfig.SpawnTimeout} second(s)."); NetworkLog.LogWarning(GetWarningMessage(triggerType, key, triggerInfo, m_NetworkManager.NetworkConfig.SpawnTimeout));
} }
foreach (var data in triggerInfo.TriggerData) foreach (var data in triggerInfo.TriggerData)

3
Runtime/Messaging/IDeferredNetworkMessageManager.cs
View File

@@ -1,3 +1,4 @@
namespace Unity.Netcode namespace Unity.Netcode
{ {
internal interface IDeferredNetworkMessageManager internal interface IDeferredNetworkMessageManager
@@ -17,7 +18,7 @@ namespace Unity.Netcode
/// There is a one second maximum lifetime of triggers to avoid memory leaks. After one second has passed /// There is a one second maximum lifetime of triggers to avoid memory leaks. After one second has passed
/// without the requested object ID being spawned, the triggers for it are automatically deleted. /// without the requested object ID being spawned, the triggers for it are automatically deleted.
/// </summary> /// </summary>
void DeferMessage(TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context); void DeferMessage(TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context, string messageType = null);
/// <summary> /// <summary>
/// Cleans up any trigger that's existed for more than a second. /// Cleans up any trigger that's existed for more than a second.

353
Runtime/Messaging/Messages/ChangeOwnershipMessage.cs
View File

@@ -1,3 +1,4 @@
namespace Unity.Netcode namespace Unity.Netcode
{ {
internal struct ChangeOwnershipMessage : INetworkMessage, INetworkSerializeByMemcpy internal struct ChangeOwnershipMessage : INetworkMessage, INetworkSerializeByMemcpy
@@ -6,11 +7,146 @@ namespace Unity.Netcode
public ulong NetworkObjectId; public ulong NetworkObjectId;
public ulong OwnerClientId; public ulong OwnerClientId;
// DANGOEXP TODO: Remove these notes or change their format
// SERVICE NOTES:
// When forwarding the message to clients on the CMB Service side,
// you can set the ClientIdCount to 0 and skip writing the ClientIds.
// See the NetworkObjet.OwnershipRequest for more potential service side additions
/// <summary>
/// When requesting, RequestClientId is the requestor.
/// When approving, RequestClientId is the owner that approved.
/// When responding (only for denied), RequestClientId is the requestor
/// </summary>
internal ulong RequestClientId;
internal int ClientIdCount;
internal ulong[] ClientIds;
internal bool DistributedAuthorityMode;
internal ushort OwnershipFlags;
internal byte OwnershipRequestResponseStatus;
private byte m_OwnershipMessageTypeFlags;
private const byte k_OwnershipChanging = 0x01;
private const byte k_OwnershipFlagsUpdate = 0x02;
private const byte k_RequestOwnership = 0x04;
private const byte k_RequestApproved = 0x08;
private const byte k_RequestDenied = 0x10;
// If no flags are set, then ownership is changing
internal bool OwnershipIsChanging
{
get
{
return GetFlag(k_OwnershipChanging);
}
set
{
SetFlag(value, k_OwnershipChanging);
}
}
internal bool OwnershipFlagsUpdate
{
get
{
return GetFlag(k_OwnershipFlagsUpdate);
}
set
{
SetFlag(value, k_OwnershipFlagsUpdate);
}
}
internal bool RequestOwnership
{
get
{
return GetFlag(k_RequestOwnership);
}
set
{
SetFlag(value, k_RequestOwnership);
}
}
internal bool RequestApproved
{
get
{
return GetFlag(k_RequestApproved);
}
set
{
SetFlag(value, k_RequestApproved);
}
}
internal bool RequestDenied
{
get
{
return GetFlag(k_RequestDenied);
}
set
{
SetFlag(value, k_RequestDenied);
}
}
private bool GetFlag(int flag)
{
return (m_OwnershipMessageTypeFlags & flag) != 0;
}
private void SetFlag(bool set, byte flag)
{
if (set) { m_OwnershipMessageTypeFlags = (byte)(m_OwnershipMessageTypeFlags | flag); }
else { m_OwnershipMessageTypeFlags = (byte)(m_OwnershipMessageTypeFlags & ~flag); }
}
public void Serialize(FastBufferWriter writer, int targetVersion) public void Serialize(FastBufferWriter writer, int targetVersion)
{ {
BytePacker.WriteValueBitPacked(writer, NetworkObjectId); BytePacker.WriteValueBitPacked(writer, NetworkObjectId);
BytePacker.WriteValueBitPacked(writer, OwnerClientId); BytePacker.WriteValueBitPacked(writer, OwnerClientId);
if (DistributedAuthorityMode)
{
BytePacker.WriteValueBitPacked(writer, ClientIdCount);
if (ClientIdCount > 0)
{
if (ClientIdCount != ClientIds.Length)
{
throw new System.Exception($"[{nameof(ChangeOwnershipMessage)}] ClientIdCount is {ClientIdCount} but the ClientIds length is {ClientIds.Length}!");
}
foreach (var clientId in ClientIds)
{
BytePacker.WriteValueBitPacked(writer, clientId);
}
}
writer.WriteValueSafe(m_OwnershipMessageTypeFlags);
if (OwnershipFlagsUpdate || OwnershipIsChanging)
{
writer.WriteValueSafe(OwnershipFlags);
}
// When requesting, it is the requestor
// When approving, it is the owner that approved
// When denied, it is the requestor
if (RequestOwnership || RequestApproved || RequestDenied)
{
writer.WriteValueSafe(RequestClientId);
if (RequestDenied)
{
writer.WriteValueSafe(OwnershipRequestResponseStatus);
}
}
}
} }
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion) public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
@@ -22,46 +158,241 @@ namespace Unity.Netcode
} }
ByteUnpacker.ReadValueBitPacked(reader, out NetworkObjectId); ByteUnpacker.ReadValueBitPacked(reader, out NetworkObjectId);
ByteUnpacker.ReadValueBitPacked(reader, out OwnerClientId); ByteUnpacker.ReadValueBitPacked(reader, out OwnerClientId);
if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
if (networkManager.DistributedAuthorityMode)
{ {
networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context); ByteUnpacker.ReadValueBitPacked(reader, out ClientIdCount);
return false; if (ClientIdCount > 0)
{
ClientIds = new ulong[ClientIdCount];
var clientId = (ulong)0;
for (int i = 0; i < ClientIdCount; i++)
{
ByteUnpacker.ReadValueBitPacked(reader, out clientId);
ClientIds[i] = clientId;
}
}
reader.ReadValueSafe(out m_OwnershipMessageTypeFlags);
if (OwnershipFlagsUpdate || OwnershipIsChanging)
{
reader.ReadValueSafe(out OwnershipFlags);
}
// When requesting, it is the requestor
// When approving, it is the owner that approved
// When denied, it is the requestor
if (RequestOwnership || RequestApproved || RequestDenied)
{
reader.ReadValueSafe(out RequestClientId);
if (RequestDenied)
{
reader.ReadValueSafe(out OwnershipRequestResponseStatus);
}
}
} }
// If we are not a DAHost instance and the NetworkObject does not exist then defer it as it very likely is not spawned yet.
// Otherwise if we are the DAHost and it does not exist then we want to forward this message because when the NetworkObject
// is made visible again, the ownership flags and owner information will be synchronized with the DAHost by the current
// authority of the NetworkObject in question.
if (!networkManager.DAHost && !networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
{
networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, GetType().Name);
return false;
}
return true; return true;
} }
public void Handle(ref NetworkContext context) public void Handle(ref NetworkContext context)
{ {
var networkManager = (NetworkManager)context.SystemOwner; var networkManager = (NetworkManager)context.SystemOwner;
var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
var originalOwner = networkObject.OwnerClientId;
// If we are the DAHost then forward this message
if (networkManager.DAHost)
{
var clientList = ClientIdCount > 0 ? ClientIds : networkManager.ConnectedClientsIds;
var message = new ChangeOwnershipMessage()
{
NetworkObjectId = NetworkObjectId,
OwnerClientId = OwnerClientId,
DistributedAuthorityMode = true,
OwnershipFlags = OwnershipFlags,
RequestClientId = RequestClientId,
ClientIdCount = 0,
m_OwnershipMessageTypeFlags = m_OwnershipMessageTypeFlags,
};
if (RequestDenied)
{
// If the local DAHost's client is not the target, then forward to the target
if (RequestClientId != networkManager.LocalClientId)
{
message.OwnershipRequestResponseStatus = OwnershipRequestResponseStatus;
networkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.Reliable, RequestClientId);
// We don't want the local DAHost's client to process this message, so exit early
return;
}
}
else if (RequestOwnership)
{
// If the DAHost client is not authority, just forward the message to the authority
if (OwnerClientId != networkManager.LocalClientId)
{
networkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.Reliable, OwnerClientId);
// We don't want the local DAHost's client to process this message, so exit early
return;
}
// Otherwise, fall through and process the request.
}
else
{
foreach (var clientId in clientList)
{
if (clientId == networkManager.LocalClientId)
{
continue;
}
// If ownership is changing and this is not an ownership request approval then ignore the OnwerClientId
// If it is just updating flags then ignore sending to the owner
// If it is a request or approving request, then ignore the RequestClientId
if ((OwnershipIsChanging && !RequestApproved && OwnerClientId == clientId) || (OwnershipFlagsUpdate && clientId == OwnerClientId)
|| ((RequestOwnership || RequestApproved) && clientId == RequestClientId))
{
continue;
}
networkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.Reliable, clientId);
}
}
// If the NetworkObject is not visible to the DAHost client, then exit early
if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
{
return;
}
}
// If ownership is changing, then run through the ownershipd changed sequence
// Note: There is some extended ownership script at the bottom of HandleOwnershipChange
// If not in distributed authority mode, then always go straight to HandleOwnershipChange
if (OwnershipIsChanging || !networkManager.DistributedAuthorityMode)
{
HandleOwnershipChange(ref context);
}
else if (networkManager.DistributedAuthorityMode)
{
// Otherwise, we handle and extended ownership update
HandleExtendedOwnershipUpdate(ref context);
}
}
/// <summary>
/// Handle the
/// </summary>
/// <param name="context"></param>
private void HandleExtendedOwnershipUpdate(ref NetworkContext context)
{
var networkManager = (NetworkManager)context.SystemOwner;
// Handle the extended ownership message types
var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
if (OwnershipFlagsUpdate)
{
// Just update the ownership flags
networkObject.Ownership = (NetworkObject.OwnershipStatus)OwnershipFlags;
}
else if (RequestOwnership)
{
// Requesting ownership, if allowed it will automatically send the ownership change message
networkObject.OwnershipRequest(RequestClientId);
}
else if (RequestDenied)
{
networkObject.OwnershipRequestResponse((NetworkObject.OwnershipRequestResponseStatus)OwnershipRequestResponseStatus);
}
}
/// <summary>
/// Handle the traditional change in ownership message type logic
/// </summary>
/// <param name="context"></param>
private void HandleOwnershipChange(ref NetworkContext context)
{
var networkManager = (NetworkManager)context.SystemOwner;
var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
// DANGO-TODO: This probably shouldn't be allowed to happen.
if (networkObject.OwnerClientId == OwnerClientId)
{
UnityEngine.Debug.LogWarning($"Unnecessary ownership changed message for {NetworkObjectId}");
}
var originalOwner = networkObject.OwnerClientId;
networkObject.OwnerClientId = OwnerClientId; networkObject.OwnerClientId = OwnerClientId;
// We are current owner. if (networkManager.DistributedAuthorityMode)
if (originalOwner == networkManager.LocalClientId) {
networkObject.Ownership = (NetworkObject.OwnershipStatus)OwnershipFlags;
}
// We are current owner (client-server) or running in distributed authority mode
if (originalOwner == networkManager.LocalClientId || networkManager.DistributedAuthorityMode)
{ {
networkObject.InvokeBehaviourOnLostOwnership(); networkObject.InvokeBehaviourOnLostOwnership();
} }
// We are new owner. // We are new owner or (client-server) or running in distributed authority mode
if (OwnerClientId == networkManager.LocalClientId) if (OwnerClientId == networkManager.LocalClientId || networkManager.DistributedAuthorityMode)
{ {
networkObject.InvokeBehaviourOnGainedOwnership(); networkObject.InvokeBehaviourOnGainedOwnership();
} }
// For all other clients that are neither the former or current owner, update the behaviours' properties // If in distributed authority mode
if (OwnerClientId != networkManager.LocalClientId && originalOwner != networkManager.LocalClientId) if (networkManager.DistributedAuthorityMode)
{ {
// Always update the network properties in distributed authority mode
for (int i = 0; i < networkObject.ChildNetworkBehaviours.Count; i++) for (int i = 0; i < networkObject.ChildNetworkBehaviours.Count; i++)
{ {
networkObject.ChildNetworkBehaviours[i].UpdateNetworkProperties(); networkObject.ChildNetworkBehaviours[i].UpdateNetworkProperties();
} }
} }
else // Otherwise update properties like we would in client-server
{
// For all other clients that are neither the former or current owner, update the behaviours' properties
if (OwnerClientId != networkManager.LocalClientId && originalOwner != networkManager.LocalClientId)
{
for (int i = 0; i < networkObject.ChildNetworkBehaviours.Count; i++)
{
networkObject.ChildNetworkBehaviours[i].UpdateNetworkProperties();
}
}
}
// Always invoke ownership change notifications
networkObject.InvokeOwnershipChanged(originalOwner, OwnerClientId); networkObject.InvokeOwnershipChanged(originalOwner, OwnerClientId);
// If this change was requested, then notify that the request was approved (doing this last so all ownership
// changes have already been applied if the callback is invoked)
if (networkManager.DistributedAuthorityMode && networkManager.LocalClientId == OwnerClientId)
{
if (RequestApproved)
{
networkObject.OwnershipRequestResponse(NetworkObject.OwnershipRequestResponseStatus.Approved);
}
// If the NetworkObject changed ownership and the Requested flag was set (i.e. it was an ownership request),
// then the new owner granted ownership removes the Requested flag and sends out an ownership status update.
if (networkObject.HasExtendedOwnershipStatus(NetworkObject.OwnershipStatusExtended.Requested))
{
networkObject.RemoveOwnershipExtended(NetworkObject.OwnershipStatusExtended.Requested);
networkObject.SendOwnershipStatusUpdate();
}
}
networkManager.NetworkMetrics.TrackOwnershipChangeReceived(context.SenderId, networkObject, context.MessageSize); networkManager.NetworkMetrics.TrackOwnershipChangeReceived(context.SenderId, networkObject, context.MessageSize);
} }
} }

33
Runtime/Messaging/Messages/ClientConnectedMessage.cs
View File

@@ -6,9 +6,13 @@ namespace Unity.Netcode
public ulong ClientId; public ulong ClientId;
public bool ShouldSynchronize;
public void Serialize(FastBufferWriter writer, int targetVersion) public void Serialize(FastBufferWriter writer, int targetVersion)
{ {
BytePacker.WriteValueBitPacked(writer, ClientId); BytePacker.WriteValueBitPacked(writer, ClientId);
writer.WriteValueSafe(ShouldSynchronize);
} }
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion) public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
@@ -19,17 +23,44 @@ namespace Unity.Netcode
return false; return false;
} }
ByteUnpacker.ReadValueBitPacked(reader, out ClientId); ByteUnpacker.ReadValueBitPacked(reader, out ClientId);
reader.ReadValueSafe(out ShouldSynchronize);
return true; return true;
} }
public void Handle(ref NetworkContext context) public void Handle(ref NetworkContext context)
{ {
var networkManager = (NetworkManager)context.SystemOwner; var networkManager = (NetworkManager)context.SystemOwner;
networkManager.ConnectionManager.ConnectedClientIds.Add(ClientId); if ((ShouldSynchronize || networkManager.CMBServiceConnection) && networkManager.DistributedAuthorityMode && networkManager.LocalClient.IsSessionOwner)
{
networkManager.SceneManager.SynchronizeNetworkObjects(ClientId);
}
else
{
// All modes support adding NetworkClients
networkManager.ConnectionManager.AddClient(ClientId);
}
if (!networkManager.ConnectionManager.ConnectedClientIds.Contains(ClientId))
{
networkManager.ConnectionManager.ConnectedClientIds.Add(ClientId);
}
if (networkManager.IsConnectedClient) if (networkManager.IsConnectedClient)
{ {
networkManager.ConnectionManager.InvokeOnPeerConnectedCallback(ClientId); networkManager.ConnectionManager.InvokeOnPeerConnectedCallback(ClientId);
} }
// DANGO-TODO: Remove the session owner object distribution check once the service handles object distribution
if (networkManager.DistributedAuthorityMode && networkManager.CMBServiceConnection && !networkManager.NetworkConfig.EnableSceneManagement)
{
// Don't redistribute for the local instance
if (ClientId != networkManager.LocalClientId)
{
// We defer redistribution to the end of the NetworkUpdateStage.PostLateUpdate
networkManager.RedistributeToClient = true;
networkManager.ClientToRedistribute = ClientId;
networkManager.TickToRedistribute = networkManager.ServerTime.Tick + 20;
}
}
} }
} }
} }

2
Runtime/Messaging/Messages/ClientDisconnectedMessage.cs
View File

@@ -25,6 +25,8 @@ namespace Unity.Netcode
public void Handle(ref NetworkContext context) public void Handle(ref NetworkContext context)
{ {
var networkManager = (NetworkManager)context.SystemOwner; var networkManager = (NetworkManager)context.SystemOwner;
// All modes support removing NetworkClients
networkManager.ConnectionManager.RemoveClient(ClientId);
networkManager.ConnectionManager.ConnectedClientIds.Remove(ClientId); networkManager.ConnectionManager.ConnectedClientIds.Remove(ClientId);
if (networkManager.IsConnectedClient) if (networkManager.IsConnectedClient)
{ {

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

@@ -10,6 +10,11 @@ namespace Unity.Netcode
public ulong OwnerClientId; public ulong OwnerClientId;
public int NetworkTick; public int NetworkTick;
// The cloud state service should set this if we are restoring a session
public bool IsRestoredSession;
public ulong CurrentSessionOwner;
// Not serialized
public bool IsDistributedAuthority;
// Not serialized, held as references to serialize NetworkVariable data // Not serialized, held as references to serialize NetworkVariable data
public HashSet<NetworkObject> SpawnedObjectsList; public HashSet<NetworkObject> SpawnedObjectsList;
@@ -38,6 +43,11 @@ namespace Unity.Netcode
BytePacker.WriteValueBitPacked(writer, OwnerClientId); BytePacker.WriteValueBitPacked(writer, OwnerClientId);
BytePacker.WriteValueBitPacked(writer, NetworkTick); BytePacker.WriteValueBitPacked(writer, NetworkTick);
if (IsDistributedAuthority)
{
writer.WriteValueSafe(IsRestoredSession);
BytePacker.WriteValueBitPacked(writer, CurrentSessionOwner);
}
if (targetVersion >= k_VersionAddClientIds) if (targetVersion >= k_VersionAddClientIds)
{ {
@@ -59,7 +69,8 @@ namespace Unity.Netcode
if (sobj.SpawnWithObservers && (sobj.CheckObjectVisibility == null || sobj.CheckObjectVisibility(OwnerClientId))) if (sobj.SpawnWithObservers && (sobj.CheckObjectVisibility == null || sobj.CheckObjectVisibility(OwnerClientId)))
{ {
sobj.Observers.Add(OwnerClientId); sobj.Observers.Add(OwnerClientId);
var sceneObject = sobj.GetMessageSceneObject(OwnerClientId); // In distributed authority mode, we send the currently known observers of each NetworkObject to the client being synchronized.
var sceneObject = sobj.GetMessageSceneObject(OwnerClientId, IsDistributedAuthority);
sceneObject.Serialize(writer); sceneObject.Serialize(writer);
++sceneObjectCount; ++sceneObjectCount;
} }
@@ -114,6 +125,11 @@ namespace Unity.Netcode
ByteUnpacker.ReadValueBitPacked(reader, out OwnerClientId); ByteUnpacker.ReadValueBitPacked(reader, out OwnerClientId);
ByteUnpacker.ReadValueBitPacked(reader, out NetworkTick); ByteUnpacker.ReadValueBitPacked(reader, out NetworkTick);
if (networkManager.DistributedAuthorityMode)
{
reader.ReadValueSafe(out IsRestoredSession);
ByteUnpacker.ReadValueBitPacked(reader, out CurrentSessionOwner);
}
if (receivedMessageVersion >= k_VersionAddClientIds) if (receivedMessageVersion >= k_VersionAddClientIds)
{ {
@@ -131,10 +147,23 @@ namespace Unity.Netcode
public void Handle(ref NetworkContext context) public void Handle(ref NetworkContext context)
{ {
var networkManager = (NetworkManager)context.SystemOwner; var networkManager = (NetworkManager)context.SystemOwner;
if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
{
NetworkLog.LogInfo($"[Client-{OwnerClientId}] Connection approved! Synchronizing...");
}
networkManager.LocalClientId = OwnerClientId; networkManager.LocalClientId = OwnerClientId;
networkManager.MessageManager.SetLocalClientId(networkManager.LocalClientId); networkManager.MessageManager.SetLocalClientId(networkManager.LocalClientId);
networkManager.NetworkMetrics.SetConnectionId(networkManager.LocalClientId); networkManager.NetworkMetrics.SetConnectionId(networkManager.LocalClientId);
if (networkManager.DistributedAuthorityMode)
{
networkManager.SetSessionOwner(CurrentSessionOwner);
if (networkManager.LocalClient.IsSessionOwner && networkManager.NetworkConfig.EnableSceneManagement)
{
networkManager.SceneManager.InitializeScenesLoaded();
}
}
var time = new NetworkTime(networkManager.NetworkTickSystem.TickRate, NetworkTick); var time = new NetworkTime(networkManager.NetworkTickSystem.TickRate, NetworkTick);
networkManager.NetworkTimeSystem.Reset(time.Time, 0.15f); // Start with a constant RTT of 150 until we receive values from the transport. networkManager.NetworkTimeSystem.Reset(time.Time, 0.15f); // Start with a constant RTT of 150 until we receive values from the transport.
networkManager.NetworkTickSystem.Reset(networkManager.NetworkTimeSystem.LocalTime, networkManager.NetworkTimeSystem.ServerTime); networkManager.NetworkTickSystem.Reset(networkManager.NetworkTimeSystem.LocalTime, networkManager.NetworkTimeSystem.ServerTime);
@@ -148,13 +177,26 @@ namespace Unity.Netcode
networkManager.ConnectionManager.ConnectedClientIds.Clear(); networkManager.ConnectionManager.ConnectedClientIds.Clear();
foreach (var clientId in ConnectedClientIds) foreach (var clientId in ConnectedClientIds)
{ {
networkManager.ConnectionManager.ConnectedClientIds.Add(clientId); if (!networkManager.ConnectionManager.ConnectedClientIds.Contains(clientId))
{
networkManager.ConnectionManager.AddClient(clientId);
}
} }
// Only if scene management is disabled do we handle NetworkObject synchronization at this point // Only if scene management is disabled do we handle NetworkObject synchronization at this point
if (!networkManager.NetworkConfig.EnableSceneManagement) if (!networkManager.NetworkConfig.EnableSceneManagement)
{ {
networkManager.SpawnManager.DestroySceneObjects(); // DANGO-TODO: This is a temporary fix for no DA CMB scene event handling.
// We will either use this same concept or provide some way for the CMB state plugin to handle it.
if (networkManager.DistributedAuthorityMode && networkManager.LocalClient.IsSessionOwner)
{
networkManager.SpawnManager.ServerSpawnSceneObjectsOnStartSweep();
}
else
{
networkManager.SpawnManager.DestroySceneObjects();
}
m_ReceivedSceneObjectData.ReadValueSafe(out uint sceneObjectCount); m_ReceivedSceneObjectData.ReadValueSafe(out uint sceneObjectCount);
// Deserializing NetworkVariable data is deferred from Receive() to Handle to avoid needing // Deserializing NetworkVariable data is deferred from Receive() to Handle to avoid needing
@@ -168,10 +210,38 @@ namespace Unity.Netcode
// Mark the client being connected // Mark the client being connected
networkManager.IsConnectedClient = true; networkManager.IsConnectedClient = true;
if (networkManager.AutoSpawnPlayerPrefabClientSide)
{
networkManager.ConnectionManager.CreateAndSpawnPlayer(OwnerClientId);
}
if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
{
NetworkLog.LogInfo($"[Client-{OwnerClientId}][Scene Management Disabled] Synchronization complete!");
}
// When scene management is disabled we notify after everything is synchronized // When scene management is disabled we notify after everything is synchronized
networkManager.ConnectionManager.InvokeOnClientConnectedCallback(context.SenderId); networkManager.ConnectionManager.InvokeOnClientConnectedCallback(context.SenderId);
} }
else
{
if (networkManager.DistributedAuthorityMode && networkManager.CMBServiceConnection && networkManager.LocalClient.IsSessionOwner && networkManager.NetworkConfig.EnableSceneManagement)
{
// Mark the client being connected
networkManager.IsConnectedClient = true;
// Spawn any in-scene placed NetworkObjects
networkManager.SpawnManager.ServerSpawnSceneObjectsOnStartSweep();
// Spawn the local player of the session owner
if (networkManager.AutoSpawnPlayerPrefabClientSide)
{
networkManager.ConnectionManager.CreateAndSpawnPlayer(OwnerClientId);
}
// Synchronize the service with the initial session owner's loaded scenes and spawned objects
networkManager.SceneManager.SynchronizeNetworkObjects(NetworkManager.ServerClientId);
}
}
ConnectedClientIds.Dispose(); ConnectedClientIds.Dispose();
} }
} }

12
Runtime/Messaging/Messages/ConnectionRequestMessage.cs
View File

@@ -8,6 +8,10 @@ namespace Unity.Netcode
public ulong ConfigHash; public ulong ConfigHash;
public bool CMBServiceConnection;
public uint TickRate;
public bool EnableSceneManagement;
public byte[] ConnectionData; public byte[] ConnectionData;
public bool ShouldSendConnectionData; public bool ShouldSendConnectionData;
@@ -30,6 +34,12 @@ namespace Unity.Netcode
// END FORBIDDEN SEGMENT // END FORBIDDEN SEGMENT
// ============================================================ // ============================================================
if (CMBServiceConnection)
{
writer.WriteValueSafe(TickRate);
writer.WriteValueSafe(EnableSceneManagement);
}
if (ShouldSendConnectionData) if (ShouldSendConnectionData)
{ {
writer.WriteValueSafe(ConfigHash); writer.WriteValueSafe(ConfigHash);
@@ -151,7 +161,7 @@ namespace Unity.Netcode
var response = new NetworkManager.ConnectionApprovalResponse var response = new NetworkManager.ConnectionApprovalResponse
{ {
Approved = true, Approved = true,
CreatePlayerObject = networkManager.NetworkConfig.PlayerPrefab != null CreatePlayerObject = networkManager.DistributedAuthorityMode && networkManager.AutoSpawnPlayerPrefabClientSide ? false : networkManager.NetworkConfig.PlayerPrefab != null
}; };
networkManager.ConnectionManager.HandleConnectionApproval(senderId, response); networkManager.ConnectionManager.HandleConnectionApproval(senderId, response);
} }

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

@@ -1,4 +1,6 @@
using System.Linq;
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
namespace Unity.Netcode namespace Unity.Netcode
{ {
internal struct CreateObjectMessage : INetworkMessage internal struct CreateObjectMessage : INetworkMessage
@@ -8,9 +10,109 @@ namespace Unity.Netcode
public NetworkObject.SceneObject ObjectInfo; public NetworkObject.SceneObject ObjectInfo;
private FastBufferReader m_ReceivedNetworkVariableData; private FastBufferReader m_ReceivedNetworkVariableData;
// DA - NGO CMB SERVICE NOTES:
// The ObserverIds and ExistingObserverIds will only be populated if k_UpdateObservers is set
// ObserverIds is the full list of observers (see below)
internal ulong[] ObserverIds;
// While this does consume a bit more bandwidth, this is only sent by the authority/owner
// and can be used to determine which clients should receive the ObjectInfo serialized data.
// All other already existing observers just need to receive the NewObserverIds and the
// NetworkObjectId
internal ulong[] NewObserverIds;
// If !IncludesSerializedObject then the NetworkObjectId will be serialized.
// This happens when we are just sending an update to the observers list
// to clients that already have the NetworkObject spawned
internal ulong NetworkObjectId;
private const byte k_IncludesSerializedObject = 0x01;
private const byte k_UpdateObservers = 0x02;
private const byte k_UpdateNewObservers = 0x04;
private byte m_CreateObjectMessageTypeFlags;
internal bool IncludesSerializedObject
{
get
{
return GetFlag(k_IncludesSerializedObject);
}
set
{
SetFlag(value, k_IncludesSerializedObject);
}
}
internal bool UpdateObservers
{
get
{
return GetFlag(k_UpdateObservers);
}
set
{
SetFlag(value, k_UpdateObservers);
}
}
internal bool UpdateNewObservers
{
get
{
return GetFlag(k_UpdateNewObservers);
}
set
{
SetFlag(value, k_UpdateNewObservers);
}
}
private bool GetFlag(int flag)
{
return (m_CreateObjectMessageTypeFlags & flag) != 0;
}
private void SetFlag(bool set, byte flag)
{
if (set) { m_CreateObjectMessageTypeFlags = (byte)(m_CreateObjectMessageTypeFlags | flag); }
else { m_CreateObjectMessageTypeFlags = (byte)(m_CreateObjectMessageTypeFlags & ~flag); }
}
public void Serialize(FastBufferWriter writer, int targetVersion) public void Serialize(FastBufferWriter writer, int targetVersion)
{ {
ObjectInfo.Serialize(writer); writer.WriteValueSafe(m_CreateObjectMessageTypeFlags);
if (UpdateObservers)
{
BytePacker.WriteValuePacked(writer, ObserverIds.Length);
foreach (var clientId in ObserverIds)
{
BytePacker.WriteValuePacked(writer, clientId);
}
}
if (UpdateNewObservers)
{
BytePacker.WriteValuePacked(writer, NewObserverIds.Length);
foreach (var clientId in NewObserverIds)
{
BytePacker.WriteValuePacked(writer, clientId);
}
}
if (IncludesSerializedObject)
{
ObjectInfo.Serialize(writer);
}
else
{
BytePacker.WriteValuePacked(writer, NetworkObjectId);
}
} }
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion) public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
@@ -21,10 +123,45 @@ namespace Unity.Netcode
return false; return false;
} }
ObjectInfo.Deserialize(reader); reader.ReadValueSafe(out m_CreateObjectMessageTypeFlags);
if (UpdateObservers)
{
var length = 0;
ByteUnpacker.ReadValuePacked(reader, out length);
ObserverIds = new ulong[length];
var clientId = (ulong)0;
for (int i = 0; i < length; i++)
{
ByteUnpacker.ReadValuePacked(reader, out clientId);
ObserverIds[i] = clientId;
}
}
if (UpdateNewObservers)
{
var length = 0;
ByteUnpacker.ReadValuePacked(reader, out length);
NewObserverIds = new ulong[length];
var clientId = (ulong)0;
for (int i = 0; i < length; i++)
{
ByteUnpacker.ReadValuePacked(reader, out clientId);
NewObserverIds[i] = clientId;
}
}
if (IncludesSerializedObject)
{
ObjectInfo.Deserialize(reader);
}
else
{
ByteUnpacker.ReadValuePacked(reader, out NetworkObjectId);
}
if (!networkManager.NetworkConfig.ForceSamePrefabs && !networkManager.SpawnManager.HasPrefab(ObjectInfo)) if (!networkManager.NetworkConfig.ForceSamePrefabs && !networkManager.SpawnManager.HasPrefab(ObjectInfo))
{ {
networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, ObjectInfo.Hash, reader, ref context); networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, ObjectInfo.Hash, reader, ref context, GetType().Name);
return false; return false;
} }
m_ReceivedNetworkVariableData = reader; m_ReceivedNetworkVariableData = reader;
@@ -38,21 +175,130 @@ namespace Unity.Netcode
// If a client receives a create object message and it is still synchronizing, then defer the object creation until it has finished synchronizing // 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()) if (networkManager.SceneManager.ShouldDeferCreateObject())
{ {
networkManager.SceneManager.DeferCreateObject(context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData); networkManager.SceneManager.DeferCreateObject(context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData, ObserverIds, NewObserverIds);
} }
else else
{ {
CreateObject(ref networkManager, context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData); if (networkManager.DistributedAuthorityMode && !IncludesSerializedObject && UpdateObservers)
{
ObjectInfo = new NetworkObject.SceneObject()
{
NetworkObjectId = NetworkObjectId,
};
}
CreateObject(ref networkManager, context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData, ObserverIds, NewObserverIds);
} }
} }
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void CreateObject(ref NetworkManager networkManager, ulong senderId, uint messageSize, NetworkObject.SceneObject sceneObject, FastBufferReader networkVariableData) internal static void CreateObject(ref NetworkManager networkManager, ref NetworkSceneManager.DeferredObjectCreation deferredObjectCreation)
{ {
var senderId = deferredObjectCreation.SenderId;
var observerIds = deferredObjectCreation.ObserverIds;
var newObserverIds = deferredObjectCreation.NewObserverIds;
var messageSize = deferredObjectCreation.MessageSize;
var sceneObject = deferredObjectCreation.SceneObject;
var networkVariableData = deferredObjectCreation.FastBufferReader;
CreateObject(ref networkManager, senderId, messageSize, sceneObject, networkVariableData, observerIds, newObserverIds);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void CreateObject(ref NetworkManager networkManager, ulong senderId, uint messageSize, NetworkObject.SceneObject sceneObject, FastBufferReader networkVariableData, ulong[] observerIds, ulong[] newObserverIds)
{
var networkObject = (NetworkObject)null;
try try
{ {
var networkObject = NetworkObject.AddSceneObject(sceneObject, networkVariableData, networkManager); if (!networkManager.DistributedAuthorityMode)
networkManager.NetworkMetrics.TrackObjectSpawnReceived(senderId, networkObject, messageSize); {
networkObject = NetworkObject.AddSceneObject(sceneObject, networkVariableData, networkManager);
}
else
{
var hasObserverIdList = observerIds != null && observerIds.Length > 0;
var hasNewObserverIdList = newObserverIds != null && newObserverIds.Length > 0;
// Depending upon visibility of the NetworkObject and the client in question, it could be that
// this client already has visibility of this NetworkObject
if (networkManager.SpawnManager.SpawnedObjects.ContainsKey(sceneObject.NetworkObjectId))
{
// If so, then just get the local instance
networkObject = networkManager.SpawnManager.SpawnedObjects[sceneObject.NetworkObjectId];
// This should not happen, logging error just in case
if (hasNewObserverIdList && newObserverIds.Contains(networkManager.LocalClientId))
{
NetworkLog.LogErrorServer($"[{nameof(CreateObjectMessage)}][Duplicate-Broadcast] Detected duplicated object creation for {sceneObject.NetworkObjectId}!");
}
else // Trap to make sure the owner is not receiving any messages it sent
if (networkManager.CMBServiceConnection && networkManager.LocalClientId == networkObject.OwnerClientId)
{
NetworkLog.LogWarning($"[{nameof(CreateObjectMessage)}][Client-{networkManager.LocalClientId}][Duplicate-CreateObjectMessage][Client Is Owner] Detected duplicated object creation for {networkObject.name}-{sceneObject.NetworkObjectId}!");
}
}
else
{
networkObject = NetworkObject.AddSceneObject(sceneObject, networkVariableData, networkManager, true);
}
// DA - NGO CMB SERVICE NOTES:
// It is possible for two clients to connect at the exact same time which, due to client-side spawning, can cause each client
// to miss their spawns. For now, all player NetworkObject spawns will always be visible to all known connected clients
var clientList = hasObserverIdList && !networkObject.IsPlayerObject ? observerIds : networkManager.ConnectedClientsIds;
// Update the observers for this instance
foreach (var clientId in clientList)
{
networkObject.Observers.Add(clientId);
}
// Mock CMB Service and forward to all clients
if (networkManager.DAHost)
{
// DA - NGO CMB SERVICE NOTES:
// (*** See above notes fist ***)
// If it is a player object freshly spawning and one or more clients all connect at the exact same time (i.e. received on effectively
// the same frame), then we need to check the observers list to make sure all players are visible upon first spawning. At a later date,
// for area of interest we will need to have some form of follow up "observer update" message to cull out players not within each
// player's AOI.
if (networkObject.IsPlayerObject && hasNewObserverIdList && clientList.Count != observerIds.Length)
{
// For same-frame newly spawned players that might not be aware of all other players, update the player's observer
// list.
observerIds = clientList.ToArray();
}
var createObjectMessage = new CreateObjectMessage()
{
ObjectInfo = sceneObject,
m_ReceivedNetworkVariableData = networkVariableData,
ObserverIds = hasObserverIdList ? observerIds : null,
NetworkObjectId = networkObject.NetworkObjectId,
IncludesSerializedObject = true,
};
foreach (var clientId in clientList)
{
// DA - NGO CMB SERVICE NOTES:
// If the authority did not specify the list of clients and the client is not an observer or we are the owner/originator
// or we are the DAHost, then we skip sending the message.
if ((!hasObserverIdList && (!networkObject.Observers.Contains(clientId)) ||
clientId == networkObject.OwnerClientId || clientId == NetworkManager.ServerClientId))
{
continue;
}
// DA - NGO CMB SERVICE NOTES:
// If this included a list of new observers and the targeted clientId is one of the observers, then send the serialized data.
// Otherwise, the targeted clientId has already has visibility (i.e. it is already spawned) and so just send the updated
// observers list to that client's instance.
createObjectMessage.IncludesSerializedObject = hasNewObserverIdList && newObserverIds.Contains(clientId);
networkManager.SpawnManager.SendSpawnCallForObject(clientId, networkObject);
}
}
}
if (networkObject != null)
{
networkManager.NetworkMetrics.TrackObjectSpawnReceived(senderId, networkObject, messageSize);
}
} }
catch (System.Exception ex) catch (System.Exception ex)
{ {

138
Runtime/Messaging/Messages/DestroyObjectMessage.cs
View File

@@ -1,3 +1,5 @@
using System.Linq;
namespace Unity.Netcode namespace Unity.Netcode
{ {
internal struct DestroyObjectMessage : INetworkMessage, INetworkSerializeByMemcpy internal struct DestroyObjectMessage : INetworkMessage, INetworkSerializeByMemcpy
@@ -6,10 +8,53 @@ namespace Unity.Netcode
public ulong NetworkObjectId; public ulong NetworkObjectId;
public bool DestroyGameObject; public bool DestroyGameObject;
private byte m_DestroyFlags;
internal int DeferredDespawnTick;
// Temporary until we make this a list
internal ulong TargetClientId;
internal bool IsDistributedAuthority;
internal const byte ClientTargetedDestroy = 0x01;
internal bool IsTargetedDestroy
{
get
{
return GetFlag(ClientTargetedDestroy);
}
set
{
SetFlag(value, ClientTargetedDestroy);
}
}
private bool GetFlag(int flag)
{
return (m_DestroyFlags & flag) != 0;
}
private void SetFlag(bool set, byte flag)
{
if (set) { m_DestroyFlags = (byte)(m_DestroyFlags | flag); }
else { m_DestroyFlags = (byte)(m_DestroyFlags & ~flag); }
}
public void Serialize(FastBufferWriter writer, int targetVersion) public void Serialize(FastBufferWriter writer, int targetVersion)
{ {
BytePacker.WriteValueBitPacked(writer, NetworkObjectId); BytePacker.WriteValueBitPacked(writer, NetworkObjectId);
if (IsDistributedAuthority)
{
writer.WriteByteSafe(m_DestroyFlags);
if (IsTargetedDestroy)
{
BytePacker.WriteValueBitPacked(writer, TargetClientId);
}
BytePacker.WriteValueBitPacked(writer, DeferredDespawnTick);
}
writer.WriteValueSafe(DestroyGameObject); writer.WriteValueSafe(DestroyGameObject);
} }
@@ -22,12 +67,25 @@ namespace Unity.Netcode
} }
ByteUnpacker.ReadValueBitPacked(reader, out NetworkObjectId); ByteUnpacker.ReadValueBitPacked(reader, out NetworkObjectId);
if (networkManager.DistributedAuthorityMode)
{
reader.ReadByteSafe(out m_DestroyFlags);
if (IsTargetedDestroy)
{
ByteUnpacker.ReadValueBitPacked(reader, out TargetClientId);
}
ByteUnpacker.ReadValueBitPacked(reader, out DeferredDespawnTick);
}
reader.ReadValueSafe(out DestroyGameObject); reader.ReadValueSafe(out DestroyGameObject);
if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject)) if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
{ {
networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context); // Client-Server mode we always defer where in distributed authority mode we only defer if it is not a targeted destroy
return false; if (!networkManager.DistributedAuthorityMode || (networkManager.DistributedAuthorityMode && !IsTargetedDestroy))
{
networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, GetType().Name);
}
} }
return true; return true;
} }
@@ -35,14 +93,80 @@ namespace Unity.Netcode
public void Handle(ref NetworkContext context) public void Handle(ref NetworkContext context)
{ {
var networkManager = (NetworkManager)context.SystemOwner; var networkManager = (NetworkManager)context.SystemOwner;
if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
var networkObject = (NetworkObject)null;
if (!networkManager.DistributedAuthorityMode)
{ {
// This is the same check and log message that happens inside OnDespawnObject, but we have to do it here // If this NetworkObject does not exist on this instance then exit early
return; if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out networkObject))
{
return;
}
}
else
{
networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out networkObject);
if (!networkManager.DAHost && networkObject == null)
{
// If this NetworkObject does not exist on this instance then exit early
return;
}
}
// DANGO-TODO: This is just a quick way to foward despawn messages to the remaining clients
if (networkManager.DistributedAuthorityMode && networkManager.DAHost)
{
var message = new DestroyObjectMessage
{
NetworkObjectId = NetworkObjectId,
DestroyGameObject = DestroyGameObject,
IsDistributedAuthority = true,
IsTargetedDestroy = IsTargetedDestroy,
TargetClientId = TargetClientId, // Just always populate this value whether we write it or not
DeferredDespawnTick = DeferredDespawnTick,
};
var ownerClientId = networkObject == null ? context.SenderId : networkObject.OwnerClientId;
var clientIds = networkObject == null ? networkManager.ConnectedClientsIds.ToList() : networkObject.Observers.ToList();
foreach (var clientId in clientIds)
{
if (clientId == networkManager.LocalClientId || clientId == ownerClientId)
{
continue;
}
networkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientId);
}
} }
networkManager.NetworkMetrics.TrackObjectDestroyReceived(context.SenderId, networkObject, context.MessageSize); // If we are deferring the despawn, then add it to the deferred despawn queue
networkManager.SpawnManager.OnDespawnObject(networkObject, DestroyGameObject); if (networkManager.DistributedAuthorityMode)
{
if (DeferredDespawnTick > 0)
{
// Clients always add it to the queue while DAHost will only add it to the queue if it is not a targeted destroy or it is and the target is the
// DAHost client.
if (!networkManager.DAHost || (networkManager.DAHost && (!IsTargetedDestroy || (IsTargetedDestroy && TargetClientId == 0))))
{
networkObject.DeferredDespawnTick = DeferredDespawnTick;
var hasCallback = networkObject.OnDeferredDespawnComplete != null;
networkManager.SpawnManager.DeferDespawnNetworkObject(NetworkObjectId, DeferredDespawnTick, hasCallback);
return;
}
}
// If this is targeted and we are not the target, then just update our local observers for this object
if (IsTargetedDestroy && TargetClientId != networkManager.LocalClientId && networkObject != null)
{
networkObject.Observers.Remove(TargetClientId);
return;
}
}
if (networkObject != null)
{
// Otherwise just despawn the NetworkObject right now
networkManager.SpawnManager.OnDespawnObject(networkObject, DestroyGameObject);
networkManager.NetworkMetrics.TrackObjectDestroyReceived(context.SenderId, networkObject, context.MessageSize);
}
} }
} }
} }

92
Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs
View File

@@ -23,6 +23,8 @@ namespace Unity.Netcode
private FastBufferReader m_ReceivedNetworkVariableData; private FastBufferReader m_ReceivedNetworkVariableData;
// DANGO-TODO: Made some modifications here that overlap/won't play nice with EnsureNetworkVariableLenghtSafety.
// Worth either merging or more cleanly separating these codepaths.
public void Serialize(FastBufferWriter writer, int targetVersion) public void Serialize(FastBufferWriter writer, int targetVersion)
{ {
if (!writer.TryBeginWrite(FastBufferWriter.GetWriteSize(NetworkObjectId) + FastBufferWriter.GetWriteSize(NetworkBehaviourIndex))) if (!writer.TryBeginWrite(FastBufferWriter.GetWriteSize(NetworkObjectId) + FastBufferWriter.GetWriteSize(NetworkBehaviourIndex)))
@@ -30,15 +32,26 @@ namespace Unity.Netcode
throw new OverflowException($"Not enough space in the buffer to write {nameof(NetworkVariableDeltaMessage)}"); throw new OverflowException($"Not enough space in the buffer to write {nameof(NetworkVariableDeltaMessage)}");
} }
var obj = NetworkBehaviour.NetworkObject;
var networkManager = obj.NetworkManagerOwner;
BytePacker.WriteValueBitPacked(writer, NetworkObjectId); BytePacker.WriteValueBitPacked(writer, NetworkObjectId);
BytePacker.WriteValueBitPacked(writer, NetworkBehaviourIndex); BytePacker.WriteValueBitPacked(writer, NetworkBehaviourIndex);
if (networkManager.DistributedAuthorityMode)
{
writer.WriteValueSafe((ushort)NetworkBehaviour.NetworkVariableFields.Count);
}
for (int i = 0; i < NetworkBehaviour.NetworkVariableFields.Count; i++) for (int i = 0; i < NetworkBehaviour.NetworkVariableFields.Count; i++)
{ {
if (!DeliveryMappedNetworkVariableIndex.Contains(i)) if (!DeliveryMappedNetworkVariableIndex.Contains(i))
{ {
// This var does not belong to the currently iterating delivery group. // This var does not belong to the currently iterating delivery group.
if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety) if (networkManager.DistributedAuthorityMode)
{
writer.WriteValueSafe<ushort>(0);
}
else if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
{ {
BytePacker.WriteValueBitPacked(writer, (ushort)0); BytePacker.WriteValueBitPacked(writer, (ushort)0);
} }
@@ -54,7 +67,7 @@ namespace Unity.Netcode
var networkVariable = NetworkBehaviour.NetworkVariableFields[i]; var networkVariable = NetworkBehaviour.NetworkVariableFields[i];
var shouldWrite = networkVariable.IsDirty() && var shouldWrite = networkVariable.IsDirty() &&
networkVariable.CanClientRead(TargetClientId) && networkVariable.CanClientRead(TargetClientId) &&
(NetworkBehaviour.NetworkManager.IsServer || networkVariable.CanClientWrite(NetworkBehaviour.NetworkManager.LocalClientId)); (networkManager.IsServer || networkVariable.CanClientWrite(networkManager.LocalClientId));
// Prevent the server from writing to the client that owns a given NetworkVariable // Prevent the server from writing to the client that owns a given NetworkVariable
// Allowing the write would send an old value to the client and cause jitter // Allowing the write would send an old value to the client and cause jitter
@@ -67,14 +80,21 @@ namespace Unity.Netcode
// The object containing the behaviour we're about to process is about to be shown to this client // The object containing the behaviour we're about to process is about to be shown to this client
// As a result, the client will get the fully serialized NetworkVariable and would be confused by // As a result, the client will get the fully serialized NetworkVariable and would be confused by
// an extraneous delta // an extraneous delta
if (NetworkBehaviour.NetworkManager.SpawnManager.ObjectsToShowToClient.ContainsKey(TargetClientId) && if (networkManager.SpawnManager.ObjectsToShowToClient.ContainsKey(TargetClientId) &&
NetworkBehaviour.NetworkManager.SpawnManager.ObjectsToShowToClient[TargetClientId] networkManager.SpawnManager.ObjectsToShowToClient[TargetClientId]
.Contains(NetworkBehaviour.NetworkObject)) .Contains(obj))
{ {
shouldWrite = false; shouldWrite = false;
} }
if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety) if (networkManager.DistributedAuthorityMode)
{
if (!shouldWrite)
{
writer.WriteValueSafe<ushort>(0);
}
}
else if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
{ {
if (!shouldWrite) if (!shouldWrite)
{ {
@@ -88,9 +108,9 @@ namespace Unity.Netcode
if (shouldWrite) if (shouldWrite)
{ {
if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety) if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
{ {
var tempWriter = new FastBufferWriter(NetworkBehaviour.NetworkManager.MessageManager.NonFragmentedMessageMaxSize, Allocator.Temp, NetworkBehaviour.NetworkManager.MessageManager.FragmentedMessageMaxSize); var tempWriter = new FastBufferWriter(networkManager.MessageManager.NonFragmentedMessageMaxSize, Allocator.Temp, networkManager.MessageManager.FragmentedMessageMaxSize);
NetworkBehaviour.NetworkVariableFields[i].WriteDelta(tempWriter); NetworkBehaviour.NetworkVariableFields[i].WriteDelta(tempWriter);
BytePacker.WriteValueBitPacked(writer, tempWriter.Length); BytePacker.WriteValueBitPacked(writer, tempWriter.Length);
@@ -103,11 +123,30 @@ namespace Unity.Netcode
} }
else else
{ {
networkVariable.WriteDelta(writer); // DANGO-TODO:
// Complex types with custom type serialization (either registered custom types or INetworkSerializable implementations) will be problematic
// Non-complex types always provide a full state update per delta
// DANGO-TODO: Add NetworkListEvent<T>.EventType awareness to the cloud-state server
if (networkManager.DistributedAuthorityMode)
{
var size_marker = writer.Position;
writer.WriteValueSafe<ushort>(0);
var start_marker = writer.Position;
networkVariable.WriteDelta(writer);
var end_marker = writer.Position;
writer.Seek(size_marker);
var size = end_marker - start_marker;
writer.WriteValueSafe((ushort)size);
writer.Seek(end_marker);
}
else
{
networkVariable.WriteDelta(writer);
}
} }
NetworkBehaviour.NetworkManager.NetworkMetrics.TrackNetworkVariableDeltaSent( networkManager.NetworkMetrics.TrackNetworkVariableDeltaSent(
TargetClientId, TargetClientId,
NetworkBehaviour.NetworkObject, obj,
networkVariable.Name, networkVariable.Name,
NetworkBehaviour.__getTypeName(), NetworkBehaviour.__getTypeName(),
writer.Length - startingSize); writer.Length - startingSize);
@@ -125,6 +164,8 @@ namespace Unity.Netcode
return true; return true;
} }
// DANGO-TODO: Made some modifications here that overlap/won't play nice with EnsureNetworkVariableLenghtSafety.
// Worth either merging or more cleanly separating these codepaths.
public void Handle(ref NetworkContext context) public void Handle(ref NetworkContext context)
{ {
var networkManager = (NetworkManager)context.SystemOwner; var networkManager = (NetworkManager)context.SystemOwner;
@@ -142,10 +183,29 @@ namespace Unity.Netcode
} }
else else
{ {
if (networkManager.DistributedAuthorityMode)
{
m_ReceivedNetworkVariableData.ReadValueSafe(out ushort variableCount);
if (variableCount != networkBehaviour.NetworkVariableFields.Count)
{
UnityEngine.Debug.LogError("Variable count mismatch");
}
}
for (int i = 0; i < networkBehaviour.NetworkVariableFields.Count; i++) for (int i = 0; i < networkBehaviour.NetworkVariableFields.Count; i++)
{ {
int varSize = 0; int varSize = 0;
if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety) if (networkManager.DistributedAuthorityMode)
{
m_ReceivedNetworkVariableData.ReadValueSafe(out ushort variableSize);
varSize = variableSize;
if (varSize == 0)
{
continue;
}
}
else if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
{ {
ByteUnpacker.ReadValueBitPacked(m_ReceivedNetworkVariableData, out varSize); ByteUnpacker.ReadValueBitPacked(m_ReceivedNetworkVariableData, out varSize);
@@ -197,6 +257,7 @@ namespace Unity.Netcode
} }
int readStartPos = m_ReceivedNetworkVariableData.Position; int readStartPos = m_ReceivedNetworkVariableData.Position;
// Read Delta so we also notify any subscribers to a change in the NetworkVariable
networkVariable.ReadDelta(m_ReceivedNetworkVariableData, networkManager.IsServer); networkVariable.ReadDelta(m_ReceivedNetworkVariableData, networkManager.IsServer);
networkManager.NetworkMetrics.TrackNetworkVariableDeltaReceived( networkManager.NetworkMetrics.TrackNetworkVariableDeltaReceived(
@@ -206,7 +267,7 @@ namespace Unity.Netcode
networkBehaviour.__getTypeName(), networkBehaviour.__getTypeName(),
context.MessageSize); context.MessageSize);
if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety) if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety || networkManager.DistributedAuthorityMode)
{ {
if (m_ReceivedNetworkVariableData.Position > (readStartPos + varSize)) if (m_ReceivedNetworkVariableData.Position > (readStartPos + varSize))
{ {
@@ -232,7 +293,10 @@ namespace Unity.Netcode
} }
else else
{ {
networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, m_ReceivedNetworkVariableData, ref context); // DANGO-TODO: Fix me!
// When a client-spawned NetworkObject is despawned by the owner client, the owner client will still get messages for deltas and cause this to
// log a warning. The issue is primarily how NetworkVariables handle updating and will require some additional re-factoring.
networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, m_ReceivedNetworkVariableData, ref context, GetType().Name);
} }
} }
} }

45
Runtime/Messaging/Messages/ParentSyncMessage.cs
View File

@@ -33,6 +33,12 @@ namespace Unity.Netcode
set => ByteUtility.SetBit(ref m_BitField, 2, value); set => ByteUtility.SetBit(ref m_BitField, 2, value);
} }
public bool AuthorityApplied
{
get => ByteUtility.GetBit(m_BitField, 3);
set => ByteUtility.SetBit(ref m_BitField, 3, value);
}
// These additional properties are used to synchronize clients with the current position, // These additional properties are used to synchronize clients with the current position,
// rotation, and scale after parenting/de-parenting (world/local space relative). This // rotation, and scale after parenting/de-parenting (world/local space relative). This
// allows users to control the final child's transform values without having to have a // allows users to control the final child's transform values without having to have a
@@ -83,9 +89,10 @@ namespace Unity.Netcode
reader.ReadValueSafe(out Rotation); reader.ReadValueSafe(out Rotation);
reader.ReadValueSafe(out Scale); reader.ReadValueSafe(out Scale);
if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId)) // If the target NetworkObject does not exist =or= the target latest parent does not exist then defer the message
if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId) || (LatestParent.HasValue && !networkManager.SpawnManager.SpawnedObjects.ContainsKey(LatestParent.Value)))
{ {
networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context); networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, GetType().Name);
return false; return false;
} }
return true; return true;
@@ -95,6 +102,16 @@ namespace Unity.Netcode
{ {
var networkManager = (NetworkManager)context.SystemOwner; var networkManager = (NetworkManager)context.SystemOwner;
var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId]; var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
// For either DA or Client-Server modes, parenting is only valid if the parent was owned by a different authority (i.e. AuthorityApplied) or the sender is from the owner (DA mode)
// or the server (client-server mode).
networkObject.AuthorityAppliedParenting = AuthorityApplied || context.SenderId == networkObject.OwnerClientId || context.SenderId == NetworkManager.ServerClientId;
if (!networkObject.AuthorityAppliedParenting && networkManager.LogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarningServer($"Client-{context.SenderId} sent a ParentSyncMessage but is not the authority of {networkObject.gameObject.name}'s {nameof(NetworkObject)} component!");
// DANGO-TODO: Still determining if we should not apply this change (I am leaning towards not allowing it).
}
networkObject.SetNetworkParenting(LatestParent, WorldPositionStays); networkObject.SetNetworkParenting(LatestParent, WorldPositionStays);
networkObject.ApplyNetworkParenting(RemoveParent); networkObject.ApplyNetworkParenting(RemoveParent);
@@ -111,6 +128,30 @@ namespace Unity.Netcode
networkObject.transform.rotation = Rotation; networkObject.transform.rotation = Rotation;
} }
networkObject.transform.localScale = Scale; networkObject.transform.localScale = Scale;
// If in distributed authority mode and we are running a DAHost and this is the DAHost, then forward the parent changed message to any remaining clients
if (networkManager.DistributedAuthorityMode && !networkManager.CMBServiceConnection && networkManager.DAHost)
{
var size = 0;
var message = this;
foreach (var client in networkManager.ConnectedClients)
{
if (client.Value.ClientId == networkObject.OwnerClientId || client.Value.ClientId == networkManager.LocalClientId)
{
continue;
}
if (networkObject.IsNetworkVisibleTo(client.Value.ClientId))
{
size = networkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, client.Value.ClientId);
networkManager.NetworkMetrics.TrackOwnershipChangeSent(client.Key, networkObject, size);
}
else
{
Debug.Log($"[DAHost][ParentingProxy] Client-{client.Value.ClientId} has no visibility to {networkObject.name}!");
}
}
}
} }
} }
} }

17
Runtime/Messaging/Messages/ProxyMessage.cs
View File

@@ -31,11 +31,24 @@ namespace Unity.Netcode
public unsafe void Handle(ref NetworkContext context) public unsafe void Handle(ref NetworkContext context)
{ {
var networkManager = (NetworkManager)context.SystemOwner; var networkManager = (NetworkManager)context.SystemOwner;
if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(WrappedMessage.Metadata.NetworkObjectId, out var networkObject)) 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."); // With distributed authority mode, we can send Rpcs before we have been notified the NetworkObject is despawned.
// DANGO-TODO: Should the CMB Service cull out any Rpcs targeting recently despawned NetworkObjects?
// DANGO-TODO: This would require the service to keep track of despawned NetworkObjects since we re-use NetworkObject identifiers.
if (networkManager.DistributedAuthorityMode)
{
if (networkManager.LogLevel == LogLevel.Developer)
{
NetworkLog.LogWarning($"[{WrappedMessage.Metadata.NetworkObjectId}, {WrappedMessage.Metadata.NetworkBehaviourId}, {WrappedMessage.Metadata.NetworkRpcMethodId}]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.");
}
return;
}
else
{
throw new InvalidOperationException($"[{WrappedMessage.Metadata.NetworkObjectId}, {WrappedMessage.Metadata.NetworkBehaviourId}, {WrappedMessage.Metadata.NetworkRpcMethodId}]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 observers = networkObject.Observers;

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

@@ -14,7 +14,7 @@ namespace Unity.Netcode
writer.WriteBytesSafe(payload.GetUnsafePtr(), payload.Length); writer.WriteBytesSafe(payload.GetUnsafePtr(), payload.Length);
} }
public static unsafe bool Deserialize(ref FastBufferReader reader, ref NetworkContext context, ref RpcMetadata metadata, ref FastBufferReader payload) public static unsafe bool Deserialize(ref FastBufferReader reader, ref NetworkContext context, ref RpcMetadata metadata, ref FastBufferReader payload, string messageType)
{ {
ByteUnpacker.ReadValueBitPacked(reader, out metadata.NetworkObjectId); ByteUnpacker.ReadValueBitPacked(reader, out metadata.NetworkObjectId);
ByteUnpacker.ReadValueBitPacked(reader, out metadata.NetworkBehaviourId); ByteUnpacker.ReadValueBitPacked(reader, out metadata.NetworkBehaviourId);
@@ -23,7 +23,7 @@ namespace Unity.Netcode
var networkManager = (NetworkManager)context.SystemOwner; var networkManager = (NetworkManager)context.SystemOwner;
if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(metadata.NetworkObjectId)) if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(metadata.NetworkObjectId))
{ {
networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, metadata.NetworkObjectId, reader, ref context); networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, metadata.NetworkObjectId, reader, ref context, messageType);
return false; return false;
} }
@@ -52,7 +52,6 @@ namespace Unity.Netcode
reader.Length); reader.Length);
} }
#endif #endif
return true; return true;
} }
@@ -107,7 +106,7 @@ namespace Unity.Netcode
public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion) public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{ {
return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer); return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, GetType().Name);
} }
public void Handle(ref NetworkContext context) public void Handle(ref NetworkContext context)
@@ -142,7 +141,7 @@ namespace Unity.Netcode
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion) public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{ {
return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer); return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, GetType().Name);
} }
public void Handle(ref NetworkContext context) public void Handle(ref NetworkContext context)
@@ -179,7 +178,8 @@ namespace Unity.Netcode
public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion) public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{ {
ByteUnpacker.ReadValuePacked(reader, out SenderClientId); ByteUnpacker.ReadValuePacked(reader, out SenderClientId);
return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer);
return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, GetType().Name);
} }
public void Handle(ref NetworkContext context) public void Handle(ref NetworkContext context)
@@ -197,4 +197,138 @@ namespace Unity.Netcode
RpcMessageHelpers.Handle(ref context, ref Metadata, ref ReadBuffer, ref rpcParams); RpcMessageHelpers.Handle(ref context, ref Metadata, ref ReadBuffer, ref rpcParams);
} }
} }
// DANGO-EXP TODO: REMOVE THIS
internal struct ForwardServerRpcMessage : INetworkMessage
{
public int Version => 0;
public ulong OwnerId;
public NetworkDelivery NetworkDelivery;
public ServerRpcMessage ServerRpcMessage;
public unsafe void Serialize(FastBufferWriter writer, int targetVersion)
{
writer.WriteValueSafe(OwnerId);
writer.WriteValueSafe(NetworkDelivery);
ServerRpcMessage.Serialize(writer, targetVersion);
}
public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
reader.ReadValueSafe(out OwnerId);
reader.ReadValueSafe(out NetworkDelivery);
ServerRpcMessage.ReadBuffer = new FastBufferReader(reader, Allocator.Persistent, reader.Length - reader.Position, sizeof(RpcMetadata));
// If deserializing failed or this message was deferred.
if (!ServerRpcMessage.Deserialize(reader, ref context, receivedMessageVersion))
{
// release this reader as the handler will either be invoked later (deferred) or will not be invoked at all.
ServerRpcMessage.ReadBuffer.Dispose();
return false;
}
return true;
}
public void Handle(ref NetworkContext context)
{
var networkManager = (NetworkManager)context.SystemOwner;
if (networkManager.DAHost)
{
try
{
// Since this is temporary, we will not be collection metrics for this.
// DAHost just forwards the message to the owner
ServerRpcMessage.WriteBuffer = new FastBufferWriter(ServerRpcMessage.ReadBuffer.Length, Allocator.TempJob);
ServerRpcMessage.WriteBuffer.WriteBytesSafe(ServerRpcMessage.ReadBuffer.ToArray());
networkManager.ConnectionManager.SendMessage(ref ServerRpcMessage, NetworkDelivery, OwnerId);
}
catch (Exception ex)
{
Debug.LogException(ex);
}
}
else
{
NetworkLog.LogErrorServer($"Received {nameof(ForwardServerRpcMessage)} on client-{networkManager.LocalClientId}! Only DAHost may forward RPC messages!");
}
ServerRpcMessage.ReadBuffer.Dispose();
ServerRpcMessage.WriteBuffer.Dispose();
}
}
// DANGO-EXP TODO: REMOVE THIS
internal struct ForwardClientRpcMessage : INetworkMessage
{
public int Version => 0;
public bool BroadCast;
public ulong[] TargetClientIds;
public NetworkDelivery NetworkDelivery;
public ClientRpcMessage ClientRpcMessage;
public unsafe void Serialize(FastBufferWriter writer, int targetVersion)
{
if (TargetClientIds == null)
{
BroadCast = true;
writer.WriteValueSafe(BroadCast);
}
else
{
BroadCast = false;
writer.WriteValueSafe(BroadCast);
writer.WriteValueSafe(TargetClientIds);
}
writer.WriteValueSafe(NetworkDelivery);
ClientRpcMessage.Serialize(writer, targetVersion);
}
public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
reader.ReadValueSafe(out BroadCast);
if (!BroadCast)
{
reader.ReadValueSafe(out TargetClientIds);
}
reader.ReadValueSafe(out NetworkDelivery);
ClientRpcMessage.ReadBuffer = new FastBufferReader(reader, Allocator.Persistent, reader.Length - reader.Position, sizeof(RpcMetadata));
// If deserializing failed or this message was deferred.
if (!ClientRpcMessage.Deserialize(reader, ref context, receivedMessageVersion))
{
// release this reader as the handler will either be invoked later (deferred) or will not be invoked at all.
ClientRpcMessage.ReadBuffer.Dispose();
return false;
}
return true;
}
public void Handle(ref NetworkContext context)
{
var networkManager = (NetworkManager)context.SystemOwner;
if (networkManager.DAHost)
{
ClientRpcMessage.WriteBuffer = new FastBufferWriter(ClientRpcMessage.ReadBuffer.Length, Allocator.TempJob);
ClientRpcMessage.WriteBuffer.WriteBytesSafe(ClientRpcMessage.ReadBuffer.ToArray());
// Since this is temporary, we will not be collection metrics for this.
// DAHost just forwards the message to the clients
if (BroadCast)
{
networkManager.ConnectionManager.SendMessage(ref ClientRpcMessage, NetworkDelivery, networkManager.ConnectedClientsIds);
}
else
{
networkManager.ConnectionManager.SendMessage(ref ClientRpcMessage, NetworkDelivery, TargetClientIds);
}
}
else
{
NetworkLog.LogErrorServer($"Received {nameof(ForwardClientRpcMessage)} on client-{networkManager.LocalClientId}! Only DAHost may forward RPC messages!");
}
ClientRpcMessage.WriteBuffer.Dispose();
ClientRpcMessage.ReadBuffer.Dispose();
}
}
} }

5
Runtime/Messaging/Messages/SceneEventMessage.cs
View File

@@ -1,3 +1,4 @@
namespace Unity.Netcode namespace Unity.Netcode
{ {
// Todo: Would be lovely to get this one nicely formatted with all the data it sends in the struct // Todo: Would be lovely to get this one nicely formatted with all the data it sends in the struct
@@ -8,6 +9,7 @@ namespace Unity.Netcode
public SceneEventData EventData; public SceneEventData EventData;
private FastBufferReader m_ReceivedData; private FastBufferReader m_ReceivedData;
public void Serialize(FastBufferWriter writer, int targetVersion) public void Serialize(FastBufferWriter writer, int targetVersion)
@@ -23,7 +25,8 @@ namespace Unity.Netcode
public void Handle(ref NetworkContext context) public void Handle(ref NetworkContext context)
{ {
((NetworkManager)context.SystemOwner).SceneManager.HandleSceneEvent(context.SenderId, m_ReceivedData); var networkManager = (NetworkManager)context.SystemOwner;
networkManager.SceneManager.HandleSceneEvent(context.SenderId, m_ReceivedData);
} }
} }
} }

19
Runtime/Messaging/Messages/ServerLogMessage.cs
View File

@@ -4,6 +4,8 @@ namespace Unity.Netcode
{ {
public int Version => 0; public int Version => 0;
public ulong SenderId;
public NetworkLog.LogType LogType; public NetworkLog.LogType LogType;
// It'd be lovely to be able to replace this with FixedString or NativeArray... // It'd be lovely to be able to replace this with FixedString or NativeArray...
// But it's not really practical. On the sending side, the user is likely to want // But it's not really practical. On the sending side, the user is likely to want
@@ -12,30 +14,39 @@ namespace Unity.Netcode
// So an allocation is unavoidable here on both sides. // So an allocation is unavoidable here on both sides.
public string Message; public string Message;
public void Serialize(FastBufferWriter writer, int targetVersion) public void Serialize(FastBufferWriter writer, int targetVersion)
{ {
writer.WriteValueSafe(LogType); writer.WriteValueSafe(LogType);
BytePacker.WriteValuePacked(writer, Message); BytePacker.WriteValuePacked(writer, Message);
BytePacker.WriteValueBitPacked(writer, SenderId);
} }
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion) public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{ {
var networkManager = (NetworkManager)context.SystemOwner; var networkManager = (NetworkManager)context.SystemOwner;
if (networkManager.IsServer && networkManager.NetworkConfig.EnableNetworkLogs)
if ((networkManager.IsServer || networkManager.LocalClient.IsSessionOwner) && networkManager.NetworkConfig.EnableNetworkLogs)
{ {
reader.ReadValueSafe(out LogType); reader.ReadValueSafe(out LogType);
ByteUnpacker.ReadValuePacked(reader, out Message); ByteUnpacker.ReadValuePacked(reader, out Message);
ByteUnpacker.ReadValuePacked(reader, out SenderId);
// If in distributed authority mode and the DAHost is not the session owner, then the DAHost will just forward the message.
if (networkManager.DAHost && networkManager.CurrentSessionOwner != networkManager.LocalClientId)
{
var message = this;
var size = networkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, networkManager.CurrentSessionOwner);
networkManager.NetworkMetrics.TrackServerLogSent(networkManager.CurrentSessionOwner, (uint)LogType, size);
return false;
}
return true; return true;
} }
return false; return false;
} }
public void Handle(ref NetworkContext context) public void Handle(ref NetworkContext context)
{ {
var networkManager = (NetworkManager)context.SystemOwner; var networkManager = (NetworkManager)context.SystemOwner;
var senderId = context.SenderId; var senderId = networkManager.DistributedAuthorityMode ? SenderId : context.SenderId;
networkManager.NetworkMetrics.TrackServerLogReceived(senderId, (uint)LogType, context.MessageSize); networkManager.NetworkMetrics.TrackServerLogReceived(senderId, (uint)LogType, context.MessageSize);

26
Runtime/Messaging/Messages/SessionOwnerMessage.cs Normal file
View File

@@ -0,0 +1,26 @@
namespace Unity.Netcode
{
internal struct SessionOwnerMessage : INetworkMessage
{
public int Version => 0;
public ulong SessionOwner;
public void Serialize(FastBufferWriter writer, int targetVersion)
{
BytePacker.WriteValuePacked(writer, SessionOwner);
}
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
ByteUnpacker.ReadValuePacked(reader, out SessionOwner);
return true;
}
public unsafe void Handle(ref NetworkContext context)
{
var networkManager = (NetworkManager)context.SystemOwner;
networkManager.SetSessionOwner(SessionOwner);
}
}
}

11
Runtime/Messaging/Messages/SessionOwnerMessage.cs.meta Normal file
View File

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

28
Runtime/Messaging/NetworkMessageManager.cs
View File

@@ -167,6 +167,28 @@ namespace Unity.Netcode
{ {
RegisterMessageType(type); RegisterMessageType(type);
} }
#if UNITY_EDITOR
if (EnableMessageOrderConsoleLog)
{
// DANGO-TODO: Remove this when we have some form of message type indices stability in place
// For now, just log the messages and their assigned types for reference purposes.
var networkManager = m_Owner as NetworkManager;
if (networkManager != null)
{
if (networkManager.DistributedAuthorityMode)
{
var messageListing = new StringBuilder();
messageListing.AppendLine("NGO Message Index to Type Listing:");
foreach (var message in m_MessageTypes)
{
messageListing.AppendLine($"[{message.Value}][{message.Key.Name}]");
}
Debug.Log(messageListing);
}
}
}
#endif
} }
catch (Exception) catch (Exception)
{ {
@@ -175,6 +197,8 @@ namespace Unity.Netcode
} }
} }
internal static bool EnableMessageOrderConsoleLog = false;
public void Dispose() public void Dispose()
{ {
if (m_Disposed) if (m_Disposed)
@@ -823,7 +847,11 @@ namespace Unity.Netcode
internal unsafe int SendMessage<T>(ref T message, NetworkDelivery delivery, in NativeList<ulong> clientIds) internal unsafe int SendMessage<T>(ref T message, NetworkDelivery delivery, in NativeList<ulong> clientIds)
where T : INetworkMessage where T : INetworkMessage
{ {
#if UTP_TRANSPORT_2_0_ABOVE
return SendMessage(ref message, delivery, new PointerListWrapper<ulong>(clientIds.GetUnsafePtr(), clientIds.Length));
#else
return SendMessage(ref message, delivery, new PointerListWrapper<ulong>((ulong*)clientIds.GetUnsafePtr(), clientIds.Length)); return SendMessage(ref message, delivery, new PointerListWrapper<ulong>((ulong*)clientIds.GetUnsafePtr(), clientIds.Length));
#endif
} }
internal unsafe void ProcessSendQueues() internal unsafe void ProcessSendQueues()

75
Runtime/Messaging/RpcTargets/AuthorityRpcTarget.cs Normal file
View File

@@ -0,0 +1,75 @@
namespace Unity.Netcode
{
internal class AuthorityRpcTarget : ServerRpcTarget
{
private ProxyRpcTarget m_AuthorityTarget;
private DirectSendRpcTarget m_DirectSendTarget;
public override void Dispose()
{
if (m_AuthorityTarget != null)
{
m_AuthorityTarget.Dispose();
m_AuthorityTarget = null;
}
if (m_DirectSendTarget != null)
{
m_DirectSendTarget.Dispose();
m_DirectSendTarget = null;
}
base.Dispose();
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
if (behaviour.NetworkManager.DistributedAuthorityMode)
{
// If invoked locally, then send locally
if (behaviour.HasAuthority)
{
if (m_UnderlyingTarget == null)
{
m_UnderlyingTarget = new LocalSendRpcTarget(m_NetworkManager);
}
m_UnderlyingTarget.Send(behaviour, ref message, delivery, rpcParams);
}
else if (behaviour.NetworkManager.DAHost)
{
if (m_DirectSendTarget == null)
{
m_DirectSendTarget = new DirectSendRpcTarget(behaviour.OwnerClientId, m_NetworkManager);
}
else
{
m_DirectSendTarget.ClientId = behaviour.OwnerClientId;
}
m_DirectSendTarget.Send(behaviour, ref message, delivery, rpcParams);
}
else // Otherwise (for now), we always proxy the RPC messages to the owner
{
if (m_AuthorityTarget == null)
{
m_AuthorityTarget = new ProxyRpcTarget(behaviour.OwnerClientId, m_NetworkManager);
}
else
{
// Since the owner can change, for now we will just clear and set the owner each time
m_AuthorityTarget.SetClientId(behaviour.OwnerClientId);
}
m_AuthorityTarget.Send(behaviour, ref message, delivery, rpcParams);
}
}
else
{
// If we are not in distributed authority mode, then we invoke the normal ServerRpc code.
base.Send(behaviour, ref message, delivery, rpcParams);
}
}
internal AuthorityRpcTarget(NetworkManager manager) : base(manager)
{
}
}
}

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

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

6
Runtime/Messaging/RpcTargets/LocalSendRpcTarget.cs
View File

@@ -36,7 +36,7 @@ namespace Unity.Netcode
MessageType = m_NetworkManager.MessageManager.GetMessageType(typeof(RpcMessage)) MessageType = m_NetworkManager.MessageManager.GetMessageType(typeof(RpcMessage))
}; };
behaviour.NetworkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnNextFrame, 0, reader, ref context); networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnNextFrame, 0, reader, ref context);
length = reader.Length; length = reader.Length;
} }
else else
@@ -49,8 +49,8 @@ namespace Unity.Netcode
#if DEVELOPMENT_BUILD || UNITY_EDITOR #if DEVELOPMENT_BUILD || UNITY_EDITOR
if (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName)) if (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName))
{ {
behaviour.NetworkManager.NetworkMetrics.TrackRpcSent( networkManager.NetworkMetrics.TrackRpcSent(
behaviour.NetworkManager.LocalClientId, networkManager.LocalClientId,
behaviour.NetworkObject, behaviour.NetworkObject,
rpcMethodName, rpcMethodName,
behaviour.__getTypeName(), behaviour.__getTypeName(),

65
Runtime/Messaging/RpcTargets/NotAuthorityRpcTarget.cs Normal file
View File

@@ -0,0 +1,65 @@
namespace Unity.Netcode
{
internal class NotAuthorityRpcTarget : NotServerRpcTarget
{
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
var networkObject = behaviour.NetworkObject;
if (m_NetworkManager.DistributedAuthorityMode)
{
if (m_GroupSendTarget == null)
{
// When mocking the CMB service, we are running a server so create a non-proxy target group
if (m_NetworkManager.DAHost)
{
m_GroupSendTarget = new RpcTargetGroup(m_NetworkManager);
}
else // Otherwise (for now), we always proxy the RPC messages
{
m_GroupSendTarget = new ProxyRpcTargetGroup(m_NetworkManager);
}
}
m_GroupSendTarget.Clear();
if (behaviour.HasAuthority)
{
foreach (var clientId in networkObject.Observers)
{
if (clientId == behaviour.OwnerClientId)
{
continue;
}
m_GroupSendTarget.Add(clientId);
}
}
else
{
foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
{
if (clientId == behaviour.OwnerClientId || !networkObject.Observers.Contains(clientId))
{
continue;
}
if (clientId == m_NetworkManager.LocalClientId)
{
m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
continue;
}
m_GroupSendTarget.Add(clientId);
}
}
m_GroupSendTarget.Target.Send(behaviour, ref message, delivery, rpcParams);
}
else
{
base.Send(behaviour, ref message, delivery, rpcParams);
}
}
internal NotAuthorityRpcTarget(NetworkManager manager) : base(manager)
{
}
}
}

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

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

9
Runtime/Messaging/RpcTargets/NotMeRpcTarget.cs
View File

@@ -49,11 +49,18 @@ namespace Unity.Netcode
{ {
continue; continue;
} }
// In distributed authority mode, we send to target id 0 (which would be a DAHost) via the group
if (clientId == NetworkManager.ServerClientId && !m_NetworkManager.DistributedAuthorityMode)
{
continue;
}
m_GroupSendTarget.Add(clientId); m_GroupSendTarget.Add(clientId);
} }
} }
m_GroupSendTarget.Target.Send(behaviour, ref message, delivery, rpcParams); m_GroupSendTarget.Target.Send(behaviour, ref message, delivery, rpcParams);
if (!behaviour.IsServer)
// In distributed authority mode, we don't use ServerRpc
if (!behaviour.IsServer && !m_NetworkManager.DistributedAuthorityMode)
{ {
m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams); m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
} }

8
Runtime/Messaging/RpcTargets/NotOwnerRpcTarget.cs
View File

@@ -40,6 +40,10 @@ namespace Unity.Netcode
{ {
continue; continue;
} }
if (clientId == NetworkManager.ServerClientId)
{
continue;
}
if (clientId == behaviour.NetworkManager.LocalClientId) if (clientId == behaviour.NetworkManager.LocalClientId)
{ {
m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams); m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
@@ -57,6 +61,10 @@ namespace Unity.Netcode
{ {
continue; continue;
} }
if (clientId == NetworkManager.ServerClientId)
{
continue;
}
if (clientId == behaviour.NetworkManager.LocalClientId) if (clientId == behaviour.NetworkManager.LocalClientId)
{ {
m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams); m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);

4
Runtime/Messaging/RpcTargets/NotServerRpcTarget.cs
View File

@@ -2,8 +2,8 @@ namespace Unity.Netcode
{ {
internal class NotServerRpcTarget : BaseRpcTarget internal class NotServerRpcTarget : BaseRpcTarget
{ {
private IGroupRpcTarget m_GroupSendTarget; protected IGroupRpcTarget m_GroupSendTarget;
private LocalSendRpcTarget m_LocalSendRpcTarget; protected LocalSendRpcTarget m_LocalSendRpcTarget;
public override void Dispose() public override void Dispose()
{ {

33
Runtime/Messaging/RpcTargets/RpcTarget.cs
View File

@@ -62,6 +62,18 @@ namespace Unity.Netcode
/// </summary> /// </summary>
ClientsAndHost, ClientsAndHost,
/// <summary> /// <summary>
/// Send this RPC to the authority.
/// In distributed authority mode, this will be the owner of the NetworkObject.
/// In normal client-server mode, this is basically the exact same thing as a server rpc.
/// </summary>
Authority,
/// <summary>
/// Send this RPC to all non-authority instances.
/// In distributed authority mode, this will be the non-owners of the NetworkObject.
/// In normal client-server mode, this is basically the exact same thing as a client rpc.
/// </summary>
NotAuthority,
/// <summary>
/// This RPC cannot be sent without passing in a target in RpcSendParams. /// This RPC cannot be sent without passing in a target in RpcSendParams.
/// </summary> /// </summary>
SpecifiedInParams SpecifiedInParams
@@ -100,7 +112,8 @@ namespace Unity.Netcode
NotMe = new NotMeRpcTarget(manager); NotMe = new NotMeRpcTarget(manager);
Me = new LocalSendRpcTarget(manager); Me = new LocalSendRpcTarget(manager);
ClientsAndHost = new ClientsAndHostRpcTarget(manager); ClientsAndHost = new ClientsAndHostRpcTarget(manager);
Authority = new AuthorityRpcTarget(manager);
NotAuthority = new NotAuthorityRpcTarget(manager);
m_CachedProxyRpcTargetGroup = new ProxyRpcTargetGroup(manager); m_CachedProxyRpcTargetGroup = new ProxyRpcTargetGroup(manager);
m_CachedTargetGroup = new RpcTargetGroup(manager); m_CachedTargetGroup = new RpcTargetGroup(manager);
m_CachedDirectSendTarget = new DirectSendRpcTarget(manager); m_CachedDirectSendTarget = new DirectSendRpcTarget(manager);
@@ -122,7 +135,8 @@ namespace Unity.Netcode
NotMe.Dispose(); NotMe.Dispose();
Me.Dispose(); Me.Dispose();
ClientsAndHost.Dispose(); ClientsAndHost.Dispose();
Authority.Dispose();
NotAuthority.Dispose();
m_CachedProxyRpcTargetGroup.Unlock(); m_CachedProxyRpcTargetGroup.Unlock();
m_CachedTargetGroup.Unlock(); m_CachedTargetGroup.Unlock();
m_CachedDirectSendTarget.Unlock(); m_CachedDirectSendTarget.Unlock();
@@ -134,7 +148,6 @@ namespace Unity.Netcode
m_CachedProxyRpcTarget.Dispose(); m_CachedProxyRpcTarget.Dispose();
} }
/// <summary> /// <summary>
/// Send to the NetworkObject's current owner. /// Send to the NetworkObject's current owner.
/// Will execute locally if the local process is the owner. /// Will execute locally if the local process is the owner.
@@ -196,6 +209,20 @@ namespace Unity.Netcode
/// </summary> /// </summary>
public BaseRpcTarget ClientsAndHost; public BaseRpcTarget ClientsAndHost;
/// <summary>
/// Send this RPC to the authority.
/// In distributed authority mode, this will be the owner of the NetworkObject.
/// In normal client-server mode, this is basically the exact same thing as a server rpc.
/// </summary>
public BaseRpcTarget Authority;
/// <summary>
/// Send this RPC to all non-authority instances.
/// In distributed authority mode, this will be the non-owners of the NetworkObject.
/// In normal client-server mode, this is basically the exact same thing as a client rpc.
/// </summary>
public BaseRpcTarget NotAuthority;
/// <summary> /// <summary>
/// Send to a specific single client ID. /// Send to a specific single client ID.
/// </summary> /// </summary>

8
Runtime/Messaging/RpcTargets/ServerRpcTarget.cs
View File

@@ -2,7 +2,7 @@ namespace Unity.Netcode
{ {
internal class ServerRpcTarget : BaseRpcTarget internal class ServerRpcTarget : BaseRpcTarget
{ {
private BaseRpcTarget m_UnderlyingTarget; protected BaseRpcTarget m_UnderlyingTarget;
public override void Dispose() public override void Dispose()
{ {
@@ -15,6 +15,12 @@ namespace Unity.Netcode
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams) internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{ {
if (behaviour.NetworkManager.DistributedAuthorityMode && behaviour.NetworkManager.CMBServiceConnection)
{
UnityEngine.Debug.LogWarning("[Invalid Target] There is no server to send to when in Distributed Authority mode!");
return;
}
if (m_UnderlyingTarget == null) if (m_UnderlyingTarget == null)
{ {
if (behaviour.NetworkManager.IsServer) if (behaviour.NetworkManager.IsServer)

769
Runtime/NetworkVariable/CollectionSerializationUtility.cs Normal file
View File

@@ -0,0 +1,769 @@
using System;
using System.Collections.Generic;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Mathematics;
namespace Unity.Netcode
{
internal static class CollectionSerializationUtility
{
public static void WriteNativeArrayDelta<T>(FastBufferWriter writer, ref NativeArray<T> value, ref NativeArray<T> previousValue) where T : unmanaged
{
// This bit vector serializes the list of which fields have changed using 1 bit per field.
// This will always be 1 bit per field of the whole array (rounded up to the nearest 8 bits)
// even if there is only one change, so as compared to serializing the index with each item,
// this will use more bandwidth when the overall bandwidth usage is small and the array is large,
// but less when the overall bandwidth usage is large. So it optimizes for the worst case while accepting
// some reduction in efficiency in the best case.
using var changes = new ResizableBitVector(Allocator.Temp);
int minLength = math.min(value.Length, previousValue.Length);
var numChanges = 0;
// Iterate the array, checking which values have changed and marking that in the bit vector
for (var i = 0; i < minLength; ++i)
{
var val = value[i];
var prevVal = previousValue[i];
if (!NetworkVariableSerialization<T>.AreEqual(ref val, ref prevVal))
{
++numChanges;
changes.Set(i);
}
}
// Mark any newly added items as well
// We don't need to mark removed items because they are captured by serializing the length
for (var i = previousValue.Length; i < value.Length; ++i)
{
++numChanges;
changes.Set(i);
}
// If the size of serializing the dela is greater than the size of serializing the whole array (i.e.,
// because almost the entire array has changed and the overhead of the change set increases bandwidth),
// then we just do a normal full serialization instead of a delta.
if (changes.GetSerializedSize() + FastBufferWriter.GetWriteSize<T>() * numChanges > FastBufferWriter.GetWriteSize<T>() * value.Length)
{
// 1 = full serialization
writer.WriteByteSafe(1);
writer.WriteValueSafe(value);
return;
}
// 0 = delta serialization
writer.WriteByte(0);
// Write the length, which will be used on the read side to resize the array
BytePacker.WriteValuePacked(writer, value.Length);
writer.WriteValueSafe(changes);
unsafe
{
var ptr = (T*)value.GetUnsafePtr();
var prevPtr = (T*)previousValue.GetUnsafePtr();
for (int i = 0; i < value.Length; ++i)
{
if (changes.IsSet(i))
{
if (i < previousValue.Length)
{
// If we have an item in the previous array for this index, we can do nested deltas!
NetworkVariableSerialization<T>.WriteDelta(writer, ref ptr[i], ref prevPtr[i]);
}
else
{
// If not, just write it normally
NetworkVariableSerialization<T>.Write(writer, ref ptr[i]);
}
}
}
}
}
public static void ReadNativeArrayDelta<T>(FastBufferReader reader, ref NativeArray<T> value) where T : unmanaged
{
// 1 = full serialization, 0 = delta serialization
reader.ReadByteSafe(out byte full);
if (full == 1)
{
// If we're doing full serialization, we fall back on reading the whole array.
value.Dispose();
reader.ReadValueSafe(out value, Allocator.Persistent);
return;
}
// If not, first read the length and the change bits
ByteUnpacker.ReadValuePacked(reader, out int length);
var changes = new ResizableBitVector(Allocator.Temp);
using var toDispose = changes;
{
reader.ReadNetworkSerializableInPlace(ref changes);
// If the length has changed, we need to resize.
// NativeArray is not resizeable, so we have to dispose and allocate a new one.
var previousLength = value.Length;
if (length != value.Length)
{
var newArray = new NativeArray<T>(length, Allocator.Persistent);
unsafe
{
UnsafeUtility.MemCpy(newArray.GetUnsafePtr(), value.GetUnsafePtr(), math.min(newArray.Length * sizeof(T), value.Length * sizeof(T)));
}
value.Dispose();
value = newArray;
}
unsafe
{
var ptr = (T*)value.GetUnsafePtr();
for (var i = 0; i < value.Length; ++i)
{
if (changes.IsSet(i))
{
if (i < previousLength)
{
// If we have an item to read a delta into, read it as a delta
NetworkVariableSerialization<T>.ReadDelta(reader, ref ptr[i]);
}
else
{
// If not, read as a standard element
NetworkVariableSerialization<T>.Read(reader, ref ptr[i]);
}
}
}
}
}
}
public static void WriteListDelta<T>(FastBufferWriter writer, ref List<T> value, ref List<T> previousValue)
{
// Lists can be null, so we have to handle that case.
// We do that by marking this as a full serialization and using the existing null handling logic
// in NetworkVariableSerialization<List<T>>
if (value == null || previousValue == null)
{
writer.WriteByteSafe(1);
NetworkVariableSerialization<List<T>>.Write(writer, ref value);
return;
}
// This bit vector serializes the list of which fields have changed using 1 bit per field.
// This will always be 1 bit per field of the whole array (rounded up to the nearest 8 bits)
// even if there is only one change, so as compared to serializing the index with each item,
// this will use more bandwidth when the overall bandwidth usage is small and the array is large,
// but less when the overall bandwidth usage is large. So it optimizes for the worst case while accepting
// some reduction in efficiency in the best case.
using var changes = new ResizableBitVector(Allocator.Temp);
int minLength = math.min(value.Count, previousValue.Count);
var numChanges = 0;
// Iterate the list, checking which values have changed and marking that in the bit vector
for (var i = 0; i < minLength; ++i)
{
var val = value[i];
var prevVal = previousValue[i];
if (!NetworkVariableSerialization<T>.AreEqual(ref val, ref prevVal))
{
++numChanges;
changes.Set(i);
}
}
// Mark any newly added items as well
// We don't need to mark removed items because they are captured by serializing the length
for (var i = previousValue.Count; i < value.Count; ++i)
{
++numChanges;
changes.Set(i);
}
// If the size of serializing the dela is greater than the size of serializing the whole array (i.e.,
// because almost the entire array has changed and the overhead of the change set increases bandwidth),
// then we just do a normal full serialization instead of a delta.
// In the case of List<T>, it's difficult to know exactly what the serialized size is going to be before
// we serialize it, so we fudge it.
if (numChanges >= value.Count * 0.9)
{
// 1 = full serialization
writer.WriteByteSafe(1);
NetworkVariableSerialization<List<T>>.Write(writer, ref value);
return;
}
// 0 = delta serialization
writer.WriteByteSafe(0);
// Write the length, which will be used on the read side to resize the list
BytePacker.WriteValuePacked(writer, value.Count);
writer.WriteValueSafe(changes);
for (int i = 0; i < value.Count; ++i)
{
if (changes.IsSet(i))
{
var reffable = value[i];
if (i < previousValue.Count)
{
// If we have an item in the previous array for this index, we can do nested deltas!
var prevReffable = previousValue[i];
NetworkVariableSerialization<T>.WriteDelta(writer, ref reffable, ref prevReffable);
}
else
{
// If not, just write it normally.
NetworkVariableSerialization<T>.Write(writer, ref reffable);
}
}
}
}
public static void ReadListDelta<T>(FastBufferReader reader, ref List<T> value)
{
// 1 = full serialization, 0 = delta serialization
reader.ReadByteSafe(out byte full);
if (full == 1)
{
// If we're doing full serialization, we fall back on reading the whole list.
NetworkVariableSerialization<List<T>>.Read(reader, ref value);
return;
}
// If not, first read the length and the change bits
ByteUnpacker.ReadValuePacked(reader, out int length);
var changes = new ResizableBitVector(Allocator.Temp);
using var toDispose = changes;
{
reader.ReadNetworkSerializableInPlace(ref changes);
// If the list shrank, we need to resize it down.
// List<T> has no method to reserve space for future elements,
// so if we have to grow it, we just do that using Add() below.
if (length < value.Count)
{
value.RemoveRange(length, value.Count - length);
}
for (var i = 0; i < length; ++i)
{
if (changes.IsSet(i))
{
if (i < value.Count)
{
// If we have an item to read a delta into, read it as a delta
T item = value[i];
NetworkVariableSerialization<T>.ReadDelta(reader, ref item);
value[i] = item;
}
else
{
// If not, just read it as a standard item.
T item = default;
NetworkVariableSerialization<T>.Read(reader, ref item);
value.Add(item);
}
}
}
}
}
// For HashSet and Dictionary, we need to have some local space to hold lists we need to serialize.
// We don't want to do allocations all the time and we know each one needs a maximum of three lists,
// so we're going to keep static lists that we can reuse in these methods.
private static class ListCache<T>
{
private static List<T> s_AddedList = new List<T>();
private static List<T> s_RemovedList = new List<T>();
private static List<T> s_ChangedList = new List<T>();
public static List<T> GetAddedList()
{
s_AddedList.Clear();
return s_AddedList;
}
public static List<T> GetRemovedList()
{
s_RemovedList.Clear();
return s_RemovedList;
}
public static List<T> GetChangedList()
{
s_ChangedList.Clear();
return s_ChangedList;
}
}
public static void WriteHashSetDelta<T>(FastBufferWriter writer, ref HashSet<T> value, ref HashSet<T> previousValue) where T : IEquatable<T>
{
// HashSets can be null, so we have to handle that case.
// We do that by marking this as a full serialization and using the existing null handling logic
// in NetworkVariableSerialization<HashSet<T>>
if (value == null || previousValue == null)
{
writer.WriteByteSafe(1);
NetworkVariableSerialization<HashSet<T>>.Write(writer, ref value);
return;
}
// No changed array because a set can't have a "changed" element, only added and removed.
var added = ListCache<T>.GetAddedList();
var removed = ListCache<T>.GetRemovedList();
// collect the new elements
foreach (var item in value)
{
if (!previousValue.Contains(item))
{
added.Add(item);
}
}
// collect the removed elements
foreach (var item in previousValue)
{
if (!value.Contains(item))
{
removed.Add(item);
}
}
// If we've got more changes than total items, we just do a full serialization
if (added.Count + removed.Count >= value.Count)
{
writer.WriteByteSafe(1);
NetworkVariableSerialization<HashSet<T>>.Write(writer, ref value);
return;
}
writer.WriteByteSafe(0);
// Write out the added and removed arrays.
writer.WriteValueSafe(added.Count);
for (var i = 0; i < added.Count; ++i)
{
var item = added[i];
NetworkVariableSerialization<T>.Write(writer, ref item);
}
writer.WriteValueSafe(removed.Count);
for (var i = 0; i < removed.Count; ++i)
{
var item = removed[i];
NetworkVariableSerialization<T>.Write(writer, ref item);
}
}
public static void ReadHashSetDelta<T>(FastBufferReader reader, ref HashSet<T> value) where T : IEquatable<T>
{
// 1 = full serialization, 0 = delta serialization
reader.ReadByteSafe(out byte full);
if (full != 0)
{
NetworkVariableSerialization<HashSet<T>>.Read(reader, ref value);
return;
}
// Read in the added and removed values
reader.ReadValueSafe(out int addedCount);
for (var i = 0; i < addedCount; ++i)
{
T item = default;
NetworkVariableSerialization<T>.Read(reader, ref item);
value.Add(item);
}
reader.ReadValueSafe(out int removedCount);
for (var i = 0; i < removedCount; ++i)
{
T item = default;
NetworkVariableSerialization<T>.Read(reader, ref item);
value.Remove(item);
}
}
public static void WriteDictionaryDelta<TKey, TVal>(FastBufferWriter writer, ref Dictionary<TKey, TVal> value, ref Dictionary<TKey, TVal> previousValue)
where TKey : IEquatable<TKey>
{
if (value == null || previousValue == null)
{
writer.WriteByteSafe(1);
NetworkVariableSerialization<Dictionary<TKey, TVal>>.Write(writer, ref value);
return;
}
var added = ListCache<KeyValuePair<TKey, TVal>>.GetAddedList();
var changed = ListCache<KeyValuePair<TKey, TVal>>.GetRemovedList();
var removed = ListCache<KeyValuePair<TKey, TVal>>.GetChangedList();
// Collect items that have been added or have changed
foreach (var item in value)
{
var val = item.Value;
var hasPrevVal = previousValue.TryGetValue(item.Key, out var prevVal);
if (!hasPrevVal)
{
added.Add(item);
}
else if (!NetworkVariableSerialization<TVal>.AreEqual(ref val, ref prevVal))
{
changed.Add(item);
}
}
// collect the items that have been removed
foreach (var item in previousValue)
{
if (!value.ContainsKey(item.Key))
{
removed.Add(item);
}
}
// If there are more changes than total values, just do a full serialization
if (added.Count + removed.Count + changed.Count >= value.Count)
{
writer.WriteByteSafe(1);
NetworkVariableSerialization<Dictionary<TKey, TVal>>.Write(writer, ref value);
return;
}
writer.WriteByteSafe(0);
// Else, write out the added, removed, and changed arrays
writer.WriteValueSafe(added.Count);
for (var i = 0; i < added.Count; ++i)
{
(var key, var val) = (added[i].Key, added[i].Value);
NetworkVariableSerialization<TKey>.Write(writer, ref key);
NetworkVariableSerialization<TVal>.Write(writer, ref val);
}
writer.WriteValueSafe(removed.Count);
for (var i = 0; i < removed.Count; ++i)
{
var key = removed[i].Key;
NetworkVariableSerialization<TKey>.Write(writer, ref key);
}
writer.WriteValueSafe(changed.Count);
for (var i = 0; i < changed.Count; ++i)
{
(var key, var val) = (changed[i].Key, changed[i].Value);
NetworkVariableSerialization<TKey>.Write(writer, ref key);
NetworkVariableSerialization<TVal>.Write(writer, ref val);
}
}
public static void ReadDictionaryDelta<TKey, TVal>(FastBufferReader reader, ref Dictionary<TKey, TVal> value)
where TKey : IEquatable<TKey>
{
// 1 = full serialization, 0 = delta serialization
reader.ReadByteSafe(out byte full);
if (full != 0)
{
NetworkVariableSerialization<Dictionary<TKey, TVal>>.Read(reader, ref value);
return;
}
// Added
reader.ReadValueSafe(out int length);
for (var i = 0; i < length; ++i)
{
(TKey key, TVal val) = (default, default);
NetworkVariableSerialization<TKey>.Read(reader, ref key);
NetworkVariableSerialization<TVal>.Read(reader, ref val);
value.Add(key, val);
}
// Removed
reader.ReadValueSafe(out length);
for (var i = 0; i < length; ++i)
{
TKey key = default;
NetworkVariableSerialization<TKey>.Read(reader, ref key);
value.Remove(key);
}
// Changed
reader.ReadValueSafe(out length);
for (var i = 0; i < length; ++i)
{
(TKey key, TVal val) = (default, default);
NetworkVariableSerialization<TKey>.Read(reader, ref key);
NetworkVariableSerialization<TVal>.Read(reader, ref val);
value[key] = val;
}
}
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
public static void WriteNativeListDelta<T>(FastBufferWriter writer, ref NativeList<T> value, ref NativeList<T> previousValue) where T : unmanaged
{
// See WriteListDelta and WriteNativeArrayDelta to understand most of this. It's basically the same,
// just adjusted for the NativeList API
using var changes = new ResizableBitVector(Allocator.Temp);
int minLength = math.min(value.Length, previousValue.Length);
var numChanges = 0;
for (var i = 0; i < minLength; ++i)
{
var val = value[i];
var prevVal = previousValue[i];
if (!NetworkVariableSerialization<T>.AreEqual(ref val, ref prevVal))
{
++numChanges;
changes.Set(i);
}
}
for (var i = previousValue.Length; i < value.Length; ++i)
{
++numChanges;
changes.Set(i);
}
if (changes.GetSerializedSize() + FastBufferWriter.GetWriteSize<T>() * numChanges > FastBufferWriter.GetWriteSize<T>() * value.Length)
{
writer.WriteByteSafe(1);
writer.WriteValueSafe(value);
return;
}
writer.WriteByte(0);
BytePacker.WriteValuePacked(writer, value.Length);
writer.WriteValueSafe(changes);
unsafe
{
#if UTP_TRANSPORT_2_0_ABOVE
var ptr = value.GetUnsafePtr();
var prevPtr = previousValue.GetUnsafePtr();
#else
var ptr = (T*)value.GetUnsafePtr();
var prevPtr = (T*)previousValue.GetUnsafePtr();
#endif
for (int i = 0; i < value.Length; ++i)
{
if (changes.IsSet(i))
{
if (i < previousValue.Length)
{
NetworkVariableSerialization<T>.WriteDelta(writer, ref ptr[i], ref prevPtr[i]);
}
else
{
NetworkVariableSerialization<T>.Write(writer, ref ptr[i]);
}
}
}
}
}
public static void ReadNativeListDelta<T>(FastBufferReader reader, ref NativeList<T> value) where T : unmanaged
{
// See ReadListDelta and ReadNativeArrayDelta to understand most of this. It's basically the same,
// just adjusted for the NativeList API
reader.ReadByteSafe(out byte full);
if (full == 1)
{
reader.ReadValueSafeInPlace(ref value);
return;
}
ByteUnpacker.ReadValuePacked(reader, out int length);
var changes = new ResizableBitVector(Allocator.Temp);
using var toDispose = changes;
{
reader.ReadNetworkSerializableInPlace(ref changes);
var previousLength = value.Length;
// The one big difference between this and NativeArray/List is that NativeList supports
// easy and fast resizing and reserving space.
if (length != value.Length)
{
value.Resize(length, NativeArrayOptions.UninitializedMemory);
}
unsafe
{
#if UTP_TRANSPORT_2_0_ABOVE
var ptr = value.GetUnsafePtr();
#else
var ptr = (T*)value.GetUnsafePtr();
#endif
for (var i = 0; i < value.Length; ++i)
{
if (changes.IsSet(i))
{
if (i < previousLength)
{
NetworkVariableSerialization<T>.ReadDelta(reader, ref ptr[i]);
}
else
{
NetworkVariableSerialization<T>.Read(reader, ref ptr[i]);
}
}
}
}
}
}
public static unsafe void WriteNativeHashSetDelta<T>(FastBufferWriter writer, ref NativeHashSet<T> value, ref NativeHashSet<T> previousValue) where T : unmanaged, IEquatable<T>
{
// See WriteHashSet; this is the same algorithm, adjusted for the NativeHashSet API
var added = stackalloc T[value.Count];
var removed = stackalloc T[previousValue.Count];
var addedCount = 0;
var removedCount = 0;
foreach (var item in value)
{
if (!previousValue.Contains(item))
{
added[addedCount] = item;
++addedCount;
}
}
foreach (var item in previousValue)
{
if (!value.Contains(item))
{
removed[removedCount] = item;
++removedCount;
}
}
#if UTP_TRANSPORT_2_0_ABOVE
if (addedCount + removedCount >= value.Count)
#else
if (addedCount + removedCount >= value.Count())
#endif
{
writer.WriteByteSafe(1);
writer.WriteValueSafe(value);
return;
}
writer.WriteByteSafe(0);
writer.WriteValueSafe(addedCount);
for (var i = 0; i < addedCount; ++i)
{
NetworkVariableSerialization<T>.Write(writer, ref added[i]);
}
writer.WriteValueSafe(removedCount);
for (var i = 0; i < removedCount; ++i)
{
NetworkVariableSerialization<T>.Write(writer, ref removed[i]);
}
}
public static void ReadNativeHashSetDelta<T>(FastBufferReader reader, ref NativeHashSet<T> value) where T : unmanaged, IEquatable<T>
{
// See ReadHashSet; this is the same algorithm, adjusted for the NativeHashSet API
reader.ReadByteSafe(out byte full);
if (full != 0)
{
reader.ReadValueSafeInPlace(ref value);
return;
}
reader.ReadValueSafe(out int addedCount);
for (var i = 0; i < addedCount; ++i)
{
T item = default;
NetworkVariableSerialization<T>.Read(reader, ref item);
value.Add(item);
}
reader.ReadValueSafe(out int removedCount);
for (var i = 0; i < removedCount; ++i)
{
T item = default;
NetworkVariableSerialization<T>.Read(reader, ref item);
value.Remove(item);
}
}
public static unsafe void WriteNativeHashMapDelta<TKey, TVal>(FastBufferWriter writer, ref NativeHashMap<TKey, TVal> value, ref NativeHashMap<TKey, TVal> previousValue)
where TKey : unmanaged, IEquatable<TKey>
where TVal : unmanaged
{
// See WriteDictionary; this is the same algorithm, adjusted for the NativeHashMap API
#if UTP_TRANSPORT_2_0_ABOVE
var added = stackalloc KVPair<TKey, TVal>[value.Count];
var changed = stackalloc KVPair<TKey, TVal>[value.Count];
var removed = stackalloc KVPair<TKey, TVal>[previousValue.Count];
#else
var added = stackalloc KeyValue<TKey, TVal>[value.Count()];
var changed = stackalloc KeyValue<TKey, TVal>[value.Count()];
var removed = stackalloc KeyValue<TKey, TVal>[previousValue.Count()];
#endif
var addedCount = 0;
var changedCount = 0;
var removedCount = 0;
foreach (var item in value)
{
var hasPrevVal = previousValue.TryGetValue(item.Key, out var prevVal);
if (!hasPrevVal)
{
added[addedCount] = item;
++addedCount;
}
else if (!NetworkVariableSerialization<TVal>.AreEqual(ref item.Value, ref prevVal))
{
changed[changedCount] = item;
++changedCount;
}
}
foreach (var item in previousValue)
{
if (!value.ContainsKey(item.Key))
{
removed[removedCount] = item;
++removedCount;
}
}
#if UTP_TRANSPORT_2_0_ABOVE
if (addedCount + removedCount + changedCount >= value.Count)
#else
if (addedCount + removedCount + changedCount >= value.Count())
#endif
{
writer.WriteByteSafe(1);
writer.WriteValueSafe(value);
return;
}
writer.WriteByteSafe(0);
writer.WriteValueSafe(addedCount);
for (var i = 0; i < addedCount; ++i)
{
(var key, var val) = (added[i].Key, added[i].Value);
NetworkVariableSerialization<TKey>.Write(writer, ref key);
NetworkVariableSerialization<TVal>.Write(writer, ref val);
}
writer.WriteValueSafe(removedCount);
for (var i = 0; i < removedCount; ++i)
{
var key = removed[i].Key;
NetworkVariableSerialization<TKey>.Write(writer, ref key);
}
writer.WriteValueSafe(changedCount);
for (var i = 0; i < changedCount; ++i)
{
(var key, var val) = (changed[i].Key, changed[i].Value);
NetworkVariableSerialization<TKey>.Write(writer, ref key);
NetworkVariableSerialization<TVal>.Write(writer, ref val);
}
}
public static void ReadNativeHashMapDelta<TKey, TVal>(FastBufferReader reader, ref NativeHashMap<TKey, TVal> value)
where TKey : unmanaged, IEquatable<TKey>
where TVal : unmanaged
{
// See ReadDictionary; this is the same algorithm, adjusted for the NativeHashMap API
reader.ReadByteSafe(out byte full);
if (full != 0)
{
reader.ReadValueSafeInPlace(ref value);
return;
}
// Added
reader.ReadValueSafe(out int length);
for (var i = 0; i < length; ++i)
{
(TKey key, TVal val) = (default, default);
NetworkVariableSerialization<TKey>.Read(reader, ref key);
NetworkVariableSerialization<TVal>.Read(reader, ref val);
value.Add(key, val);
}
// Removed
reader.ReadValueSafe(out length);
for (var i = 0; i < length; ++i)
{
TKey key = default;
NetworkVariableSerialization<TKey>.Read(reader, ref key);
value.Remove(key);
}
// Changed
reader.ReadValueSafe(out length);
for (var i = 0; i < length; ++i)
{
(TKey key, TVal val) = (default, default);
NetworkVariableSerialization<TKey>.Read(reader, ref key);
NetworkVariableSerialization<TVal>.Read(reader, ref val);
value[key] = val;
}
}
#endif
}
}

3
Runtime/NetworkVariable/CollectionSerializationUtility.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: c822ece4e24f4676861e07288a7f8526
timeCreated: 1705437250

49
Runtime/NetworkVariable/Collections/NetworkList.cs
View File

@@ -24,6 +24,7 @@ namespace Unity.Netcode
/// The callback to be invoked when the list gets changed /// The callback to be invoked when the list gets changed
/// </summary> /// </summary>
public event OnListChangedDelegate OnListChanged; public event OnListChangedDelegate OnListChanged;
internal override NetworkVariableType Type => NetworkVariableType.NetworkList;
/// <summary> /// <summary>
/// Constructor method for <see cref="NetworkList"/> /// Constructor method for <see cref="NetworkList"/>
@@ -98,7 +99,7 @@ namespace Unity.Netcode
break; break;
case NetworkListEvent<T>.EventType.Insert: case NetworkListEvent<T>.EventType.Insert:
{ {
writer.WriteValueSafe(element.Index); BytePacker.WriteValueBitPacked(writer, element.Index);
NetworkVariableSerialization<T>.Write(writer, ref element.Value); NetworkVariableSerialization<T>.Write(writer, ref element.Value);
} }
break; break;
@@ -109,12 +110,12 @@ namespace Unity.Netcode
break; break;
case NetworkListEvent<T>.EventType.RemoveAt: case NetworkListEvent<T>.EventType.RemoveAt:
{ {
writer.WriteValueSafe(element.Index); BytePacker.WriteValueBitPacked(writer, element.Index);
} }
break; break;
case NetworkListEvent<T>.EventType.Value: case NetworkListEvent<T>.EventType.Value:
{ {
writer.WriteValueSafe(element.Index); BytePacker.WriteValueBitPacked(writer, element.Index);
NetworkVariableSerialization<T>.Write(writer, ref element.Value); NetworkVariableSerialization<T>.Write(writer, ref element.Value);
} }
break; break;
@@ -130,6 +131,20 @@ namespace Unity.Netcode
/// <inheritdoc /> /// <inheritdoc />
public override void WriteField(FastBufferWriter writer) public override void WriteField(FastBufferWriter writer)
{ {
if (m_NetworkManager.DistributedAuthorityMode)
{
writer.WriteValueSafe(NetworkVariableSerialization<T>.Type);
if (NetworkVariableSerialization<T>.Type == CollectionItemType.Unmanaged)
{
// Write the size of the unmanaged serialized type as it has a fixed size. This allows the CMB runtime to correctly read the unmanged type.
var placeholder = new T();
var startPos = writer.Position;
NetworkVariableSerialization<T>.Write(writer, ref placeholder);
var size = writer.Position - startPos;
writer.Seek(startPos);
BytePacker.WriteValueBitPacked(writer, size);
}
}
writer.WriteValueSafe((ushort)m_List.Length); writer.WriteValueSafe((ushort)m_List.Length);
for (int i = 0; i < m_List.Length; i++) for (int i = 0; i < m_List.Length; i++)
{ {
@@ -141,6 +156,15 @@ namespace Unity.Netcode
public override void ReadField(FastBufferReader reader) public override void ReadField(FastBufferReader reader)
{ {
m_List.Clear(); m_List.Clear();
if (m_NetworkManager.DistributedAuthorityMode)
{
// Collection item type is used by the CMB rust service, drop value here.
reader.ReadValueSafe(out CollectionItemType type);
if (type == CollectionItemType.Unmanaged)
{
ByteUnpacker.ReadValueBitPacked(reader, out int _);
}
}
reader.ReadValueSafe(out ushort count); reader.ReadValueSafe(out ushort count);
for (int i = 0; i < count; i++) for (int i = 0; i < count; i++)
{ {
@@ -189,7 +213,7 @@ namespace Unity.Netcode
break; break;
case NetworkListEvent<T>.EventType.Insert: case NetworkListEvent<T>.EventType.Insert:
{ {
reader.ReadValueSafe(out int index); ByteUnpacker.ReadValueBitPacked(reader, out int index);
var value = new T(); var value = new T();
NetworkVariableSerialization<T>.Read(reader, ref value); NetworkVariableSerialization<T>.Read(reader, ref value);
@@ -261,7 +285,7 @@ namespace Unity.Netcode
break; break;
case NetworkListEvent<T>.EventType.RemoveAt: case NetworkListEvent<T>.EventType.RemoveAt:
{ {
reader.ReadValueSafe(out int index); ByteUnpacker.ReadValueBitPacked(reader, out int index);
T value = m_List[index]; T value = m_List[index];
m_List.RemoveAt(index); m_List.RemoveAt(index);
@@ -289,7 +313,7 @@ namespace Unity.Netcode
break; break;
case NetworkListEvent<T>.EventType.Value: case NetworkListEvent<T>.EventType.Value:
{ {
reader.ReadValueSafe(out int index); ByteUnpacker.ReadValueBitPacked(reader, out int index);
var value = new T(); var value = new T();
NetworkVariableSerialization<T>.Read(reader, ref value); NetworkVariableSerialization<T>.Read(reader, ref value);
if (index >= m_List.Length) if (index >= m_List.Length)
@@ -367,7 +391,7 @@ namespace Unity.Netcode
public void Add(T item) public void Add(T item)
{ {
// check write permissions // check write permissions
if (!CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId)) if (!CanClientWrite(m_NetworkManager.LocalClientId))
{ {
throw new InvalidOperationException("Client is not allowed to write to this NetworkList"); throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
} }
@@ -388,7 +412,7 @@ namespace Unity.Netcode
public void Clear() public void Clear()
{ {
// check write permissions // check write permissions
if (!CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId)) if (!CanClientWrite(m_NetworkManager.LocalClientId))
{ {
throw new InvalidOperationException("Client is not allowed to write to this NetworkList"); throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
} }
@@ -414,7 +438,7 @@ namespace Unity.Netcode
public bool Remove(T item) public bool Remove(T item)
{ {
// check write permissions // check write permissions
if (!CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId)) if (!CanClientWrite(m_NetworkManager.LocalClientId))
{ {
throw new InvalidOperationException("Client is not allowed to write to this NetworkList"); throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
} }
@@ -449,7 +473,7 @@ namespace Unity.Netcode
public void Insert(int index, T item) public void Insert(int index, T item)
{ {
// check write permissions // check write permissions
if (!CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId)) if (!CanClientWrite(m_NetworkManager.LocalClientId))
{ {
throw new InvalidOperationException("Client is not allowed to write to this NetworkList"); throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
} }
@@ -478,7 +502,7 @@ namespace Unity.Netcode
public void RemoveAt(int index) public void RemoveAt(int index)
{ {
// check write permissions // check write permissions
if (!CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId)) if (!CanClientWrite(m_NetworkManager.LocalClientId))
{ {
throw new InvalidOperationException("Client is not allowed to write to this NetworkList"); throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
} }
@@ -503,7 +527,7 @@ namespace Unity.Netcode
set set
{ {
// check write permissions // check write permissions
if (!CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId)) if (!CanClientWrite(m_NetworkManager.LocalClientId))
{ {
throw new InvalidOperationException("Client is not allowed to write to this NetworkList"); throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
} }
@@ -551,6 +575,7 @@ namespace Unity.Netcode
{ {
m_List.Dispose(); m_List.Dispose();
m_DirtyEvents.Dispose(); m_DirtyEvents.Dispose();
base.Dispose();
} }
} }

28
Runtime/NetworkVariable/NetworkVariable.cs
View File

@@ -21,6 +21,7 @@ namespace Unity.Netcode
/// The callback to be invoked when the value gets changed /// The callback to be invoked when the value gets changed
/// </summary> /// </summary>
public OnValueChangedDelegate OnValueChanged; public OnValueChangedDelegate OnValueChanged;
internal override NetworkVariableType Type => NetworkVariableType.Value;
/// <summary> /// <summary>
/// Constructor for <see cref="NetworkVariable{T}"/> /// Constructor for <see cref="NetworkVariable{T}"/>
@@ -43,6 +44,19 @@ namespace Unity.Netcode
m_PreviousValue = default; m_PreviousValue = default;
} }
/// <summary>
/// Resets the NetworkVariable when the associated NetworkObject is not spawned
/// </summary>
/// <param name="value">the value to reset the NetworkVariable to (if none specified it resets to the default)</param>
public void Reset(T value = default)
{
if (m_NetworkBehaviour == null || m_NetworkBehaviour != null && !m_NetworkBehaviour.NetworkObject.IsSpawned)
{
m_InternalValue = value;
m_PreviousValue = default;
}
}
/// <summary> /// <summary>
/// The internal value of the NetworkVariable /// The internal value of the NetworkVariable
/// </summary> /// </summary>
@@ -68,9 +82,9 @@ namespace Unity.Netcode
return; return;
} }
if (m_NetworkBehaviour && !CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId)) if (m_NetworkManager && !CanClientWrite(m_NetworkManager.LocalClientId))
{ {
throw new InvalidOperationException("Client is not allowed to write to this NetworkVariable"); throw new InvalidOperationException($"[Client-{m_NetworkManager.LocalClientId}][{m_NetworkBehaviour.name}][{Name}] Write permissions ({WritePerm}) for this client instance is not allowed!");
} }
Set(value); Set(value);
@@ -104,6 +118,8 @@ namespace Unity.Netcode
} }
m_PreviousValue = default; m_PreviousValue = default;
base.Dispose();
} }
~NetworkVariable() ~NetworkVariable()
@@ -142,16 +158,16 @@ namespace Unity.Netcode
/// </summary> /// </summary>
public override void ResetDirty() public override void ResetDirty()
{ {
base.ResetDirty();
// Resetting the dirty value declares that the current value is not dirty // Resetting the dirty value declares that the current value is not dirty
// Therefore, we set the m_PreviousValue field to a duplicate of the current // Therefore, we set the m_PreviousValue field to a duplicate of the current
// field, so that our next dirty check is made against the current "not dirty" // field, so that our next dirty check is made against the current "not dirty"
// value. // value.
if (!m_HasPreviousValue || !NetworkVariableSerialization<T>.AreEqual(ref m_InternalValue, ref m_PreviousValue)) if (IsDirty())
{ {
m_HasPreviousValue = true; m_HasPreviousValue = true;
NetworkVariableSerialization<T>.Duplicate(m_InternalValue, ref m_PreviousValue); NetworkVariableSerialization<T>.Duplicate(m_InternalValue, ref m_PreviousValue);
} }
base.ResetDirty();
} }
/// <summary> /// <summary>
@@ -173,7 +189,7 @@ namespace Unity.Netcode
/// <param name="writer">The stream to write the value to</param> /// <param name="writer">The stream to write the value to</param>
public override void WriteDelta(FastBufferWriter writer) public override void WriteDelta(FastBufferWriter writer)
{ {
WriteField(writer); NetworkVariableSerialization<T>.WriteDelta(writer, ref m_InternalValue, ref m_PreviousValue);
} }
/// <summary> /// <summary>
@@ -189,7 +205,7 @@ namespace Unity.Netcode
// would be stored in different fields // would be stored in different fields
T previousValue = m_InternalValue; T previousValue = m_InternalValue;
NetworkVariableSerialization<T>.Read(reader, ref m_InternalValue); NetworkVariableSerialization<T>.ReadDelta(reader, ref m_InternalValue);
if (keepDirtyDelta) if (keepDirtyDelta)
{ {

97
Runtime/NetworkVariable/NetworkVariableBase.cs
View File

@@ -18,6 +18,22 @@ namespace Unity.Netcode
/// </summary> /// </summary>
private protected NetworkBehaviour m_NetworkBehaviour; private protected NetworkBehaviour m_NetworkBehaviour;
private NetworkManager m_InternalNetworkManager;
internal virtual NetworkVariableType Type => NetworkVariableType.Custom;
private protected NetworkManager m_NetworkManager
{
get
{
if (m_InternalNetworkManager == null && m_NetworkBehaviour && m_NetworkBehaviour.NetworkObject?.NetworkManager)
{
m_InternalNetworkManager = m_NetworkBehaviour.NetworkObject?.NetworkManager;
}
return m_InternalNetworkManager;
}
}
public NetworkBehaviour GetBehaviour() public NetworkBehaviour GetBehaviour()
{ {
return m_NetworkBehaviour; return m_NetworkBehaviour;
@@ -29,7 +45,14 @@ namespace Unity.Netcode
/// <param name="networkBehaviour">The NetworkBehaviour the NetworkVariable belongs to</param> /// <param name="networkBehaviour">The NetworkBehaviour the NetworkVariable belongs to</param>
public void Initialize(NetworkBehaviour networkBehaviour) public void Initialize(NetworkBehaviour networkBehaviour)
{ {
m_InternalNetworkManager = null;
m_NetworkBehaviour = networkBehaviour; m_NetworkBehaviour = networkBehaviour;
if (m_NetworkBehaviour && m_NetworkBehaviour.NetworkObject?.NetworkManager)
{
m_InternalNetworkManager = m_NetworkBehaviour.NetworkObject?.NetworkManager;
// When in distributed authority mode, there is no such thing as server write permissions
InternalWritePerm = m_InternalNetworkManager.DistributedAuthorityMode ? NetworkVariableWritePermission.Owner : InternalWritePerm;
}
} }
/// <summary> /// <summary>
@@ -53,7 +76,7 @@ namespace Unity.Netcode
NetworkVariableWritePermission writePerm = DefaultWritePerm) NetworkVariableWritePermission writePerm = DefaultWritePerm)
{ {
ReadPerm = readPerm; ReadPerm = readPerm;
WritePerm = writePerm; InternalWritePerm = writePerm;
} }
/// <summary> /// <summary>
@@ -76,7 +99,17 @@ namespace Unity.Netcode
/// <summary> /// <summary>
/// The write permission for this var /// The write permission for this var
/// </summary> /// </summary>
public readonly NetworkVariableWritePermission WritePerm; public NetworkVariableWritePermission WritePerm
{
get
{
return InternalWritePerm;
}
}
// We had to change the Write Permission in distributed authority.
// (It is too bad we initially declared it as readonly)
internal NetworkVariableWritePermission InternalWritePerm;
/// <summary> /// <summary>
/// Sets whether or not the variable needs to be delta synced /// Sets whether or not the variable needs to be delta synced
@@ -92,12 +125,17 @@ namespace Unity.Netcode
} }
} }
internal static bool IgnoreInitializeWarning;
protected void MarkNetworkBehaviourDirty() protected void MarkNetworkBehaviourDirty()
{ {
if (m_NetworkBehaviour == null) if (m_NetworkBehaviour == null)
{ {
Debug.LogWarning($"NetworkVariable is written to, but doesn't know its NetworkBehaviour yet. " + if (!IgnoreInitializeWarning)
"Are you modifying a NetworkVariable before the NetworkObject is spawned?"); {
Debug.LogWarning($"NetworkVariable is written to, but doesn't know its NetworkBehaviour yet. " +
"Are you modifying a NetworkVariable before the NetworkObject is spawned?");
}
return; return;
} }
if (m_NetworkBehaviour.NetworkManager.ShutdownInProgress) if (m_NetworkBehaviour.NetworkManager.ShutdownInProgress)
@@ -109,7 +147,7 @@ namespace Unity.Netcode
} }
return; return;
} }
m_NetworkBehaviour.NetworkManager.BehaviourUpdater.AddForUpdate(m_NetworkBehaviour.NetworkObject); m_NetworkBehaviour.NetworkManager.BehaviourUpdater?.AddForUpdate(m_NetworkBehaviour.NetworkObject);
} }
/// <summary> /// <summary>
@@ -136,6 +174,11 @@ namespace Unity.Netcode
/// <returns>Whether or not the client has permission to read</returns> /// <returns>Whether or not the client has permission to read</returns>
public bool CanClientRead(ulong clientId) public bool CanClientRead(ulong clientId)
{ {
// When in distributed authority mode, everyone can read (but only the owner can write)
if (m_NetworkManager != null && m_NetworkManager.DistributedAuthorityMode)
{
return true;
}
switch (ReadPerm) switch (ReadPerm)
{ {
default: default:
@@ -201,6 +244,50 @@ namespace Unity.Netcode
/// </summary> /// </summary>
public virtual void Dispose() public virtual void Dispose()
{ {
m_InternalNetworkManager = null;
} }
} }
/// <summary>
/// Enum representing the different types of Network Variables.
/// </summary>
public enum NetworkVariableType : byte
{
/// <summary>
/// Value
/// Used for all of the basic NetworkVariables that contain a single value
/// </summary>
Value = 0,
/// <summary>
/// Custom
/// For any custom implemented extension of the NetworkVariableBase
/// </summary>
Custom = 1,
/// <summary>
/// NetworkList
/// </summary>
NetworkList = 2
}
public enum CollectionItemType : byte
{
/// <summary>
/// For any type that is not valid inside a NetworkVariable collection
/// </summary>
Unknown = 0,
/// <summary>
/// The following types are valid types inside of NetworkVariable collections
/// </summary>
Short = 1,
UShort = 2,
Int = 3,
UInt = 4,
Long = 5,
ULong = 6,
Unmanaged = 7,
}
} }

956
Runtime/NetworkVariable/NetworkVariableSerialization.cs
View File

File diff suppressed because it is too large Load Diff

115
Runtime/NetworkVariable/ResizableBitVector.cs Normal file
View File

@@ -0,0 +1,115 @@
using System;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
namespace Unity.Netcode
{
/// <summary>
/// This is a simple resizable bit vector - i.e., a list of flags that use 1 bit each and can
/// grow to an indefinite size. This is backed by a NativeList&lt;byte&gt; instead of a single
/// integer value, allowing it to contain any size of memory. Contains built-in serialization support.
/// </summary>
internal struct ResizableBitVector : INetworkSerializable, IDisposable
{
private NativeList<byte> m_Bits;
private const int k_Divisor = sizeof(byte) * 8;
public ResizableBitVector(Allocator allocator)
{
m_Bits = new NativeList<byte>(allocator);
}
public void Dispose()
{
m_Bits.Dispose();
}
public int GetSerializedSize()
{
return sizeof(int) + m_Bits.Length;
}
private (int, int) GetBitData(int i)
{
var index = i / k_Divisor;
var bitWithinIndex = i % k_Divisor;
return (index, bitWithinIndex);
}
/// <summary>
/// Set bit 'i' - i.e., bit 0 is 00000001, bit 1 is 00000010, and so on.
/// There is no upper bound on i except for the memory available in the system.
/// </summary>
/// <param name="i"></param>
public void Set(int i)
{
var (index, bitWithinIndex) = GetBitData(i);
if (index >= m_Bits.Length)
{
m_Bits.Resize(index + 1, NativeArrayOptions.ClearMemory);
}
m_Bits[index] |= (byte)(1 << bitWithinIndex);
}
/// <summary>
/// Unset bit 'i' - i.e., bit 0 is 00000001, bit 1 is 00000010, and so on.
/// There is no upper bound on i except for the memory available in the system.
/// Note that once a BitVector has grown to a certain size, it will not shrink back down,
/// so if you set and unset every bit, it will still serialize at its high watermark size.
/// </summary>
/// <param name="i"></param>
public void Unset(int i)
{
var (index, bitWithinIndex) = GetBitData(i);
if (index >= m_Bits.Length)
{
return;
}
m_Bits[index] &= (byte)~(1 << bitWithinIndex);
}
/// <summary>
/// Check if bit 'i' is set - i.e., bit 0 is 00000001, bit 1 is 00000010, and so on.
/// There is no upper bound on i except for the memory available in the system.
/// </summary>
/// <param name="i"></param>
public bool IsSet(int i)
{
var (index, bitWithinIndex) = GetBitData(i);
if (index >= m_Bits.Length)
{
return false;
}
return (m_Bits[index] & (byte)(1 << bitWithinIndex)) != 0;
}
public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
{
var length = m_Bits.Length;
serializer.SerializeValue(ref length);
m_Bits.ResizeUninitialized(length);
var ptr = m_Bits.GetUnsafePtr();
{
if (serializer.IsReader)
{
#if UTP_TRANSPORT_2_0_ABOVE
serializer.GetFastBufferReader().ReadBytesSafe(ptr, length);
#else
serializer.GetFastBufferReader().ReadBytesSafe((byte*)ptr, length);
#endif
}
else
{
#if UTP_TRANSPORT_2_0_ABOVE
serializer.GetFastBufferWriter().WriteBytesSafe(ptr, length);
#else
serializer.GetFastBufferWriter().WriteBytesSafe((byte*)ptr, length);
#endif
}
}
}
}
}

3
Runtime/NetworkVariable/ResizableBitVector.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 664696a622e244dfa43b26628c05e4a6
timeCreated: 1705437231

5
Runtime/SceneManagement/DefaultSceneManagerHandler.cs
View File

@@ -18,6 +18,7 @@ namespace Unity.Netcode
public bool IsAssigned; public bool IsAssigned;
public Scene Scene; public Scene Scene;
} }
public bool IsIntegrationTest() { return false; }
internal Dictionary<string, Dictionary<int, SceneEntry>> SceneNameToSceneHandles = new Dictionary<string, Dictionary<int, SceneEntry>>(); internal Dictionary<string, Dictionary<int, SceneEntry>> SceneNameToSceneHandles = new Dictionary<string, Dictionary<int, SceneEntry>>();
@@ -327,8 +328,8 @@ namespace Unity.Netcode
public void SetClientSynchronizationMode(ref NetworkManager networkManager, LoadSceneMode mode) public void SetClientSynchronizationMode(ref NetworkManager networkManager, LoadSceneMode mode)
{ {
var sceneManager = networkManager.SceneManager; var sceneManager = networkManager.SceneManager;
// Don't let client's set this value // Don't let non-authority set this value
if (!networkManager.IsServer) if ((!networkManager.DistributedAuthorityMode && !networkManager.IsServer) || (networkManager.DistributedAuthorityMode && !networkManager.LocalClient.IsSessionOwner))
{ {
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal) if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{ {

2
Runtime/SceneManagement/ISceneManagerHandler.cs
View File

@@ -32,5 +32,7 @@ namespace Unity.Netcode
void SetClientSynchronizationMode(ref NetworkManager networkManager, LoadSceneMode mode); void SetClientSynchronizationMode(ref NetworkManager networkManager, LoadSceneMode mode);
bool ClientShouldPassThrough(string sceneName, bool isPrimaryScene, LoadSceneMode clientSynchronizationMode, NetworkManager networkManager); bool ClientShouldPassThrough(string sceneName, bool isPrimaryScene, LoadSceneMode clientSynchronizationMode, NetworkManager networkManager);
bool IsIntegrationTest();
} }
} }

774
Runtime/SceneManagement/NetworkSceneManager.cs
View File

File diff suppressed because it is too large Load Diff

314
Runtime/SceneManagement/SceneEventData.cs
View File

@@ -1,6 +1,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Text;
using Unity.Collections; using Unity.Collections;
using UnityEngine.SceneManagement; using UnityEngine.SceneManagement;
@@ -114,7 +115,10 @@ namespace Unity.Netcode
/// Only used for <see cref="SceneEventType.Synchronize"/> scene events, this assures permissions when writing /// Only used for <see cref="SceneEventType.Synchronize"/> scene events, this assures permissions when writing
/// NetworkVariable information. If that process changes, then we need to update this /// NetworkVariable information. If that process changes, then we need to update this
/// In distributed authority mode this is used to route messages to the appropriate destination client
internal ulong TargetClientId; internal ulong TargetClientId;
/// Only used with a DAHost
internal ulong SenderClientId;
private Dictionary<uint, List<NetworkObject>> m_SceneNetworkObjects; private Dictionary<uint, List<NetworkObject>> m_SceneNetworkObjects;
private Dictionary<uint, long> m_SceneNetworkObjectDataOffsets; private Dictionary<uint, long> m_SceneNetworkObjectDataOffsets;
@@ -243,8 +247,76 @@ namespace Unity.Netcode
{ {
SceneHandlesToSynchronize.Clear(); SceneHandlesToSynchronize.Clear();
} }
ForwardSynchronization = false;
} }
/// <summary>
/// Used with SortParentedNetworkObjects to sort the children of the root parent NetworkObject
/// </summary>
/// <param name="first">object to be sorted</param>
/// <param name="second">object to be compared to for sorting the first object</param>
/// <returns></returns>
private int SortChildrenNetworkObjects(NetworkObject first, NetworkObject second)
{
var firstParent = first.GetCachedParent()?.GetComponent<NetworkObject>();
// If the second is the first's parent then move the first down
if (firstParent != null && firstParent == second)
{
return 1;
}
var secondParent = second.GetCachedParent()?.GetComponent<NetworkObject>();
// If the first is the second's parent then move the first up
if (secondParent != null && secondParent == first)
{
return -1;
}
// Otherwise, don't move the first at all
return 0;
}
/// <summary>
/// Sorts the synchronization order of the NetworkObjects to be serialized
/// by parents before children order
/// </summary>
private void SortParentedNetworkObjects()
{
var networkObjectList = m_NetworkObjectsSync.ToList();
foreach (var networkObject in networkObjectList)
{
// Find only the root parent NetworkObjects
if (networkObject.transform.childCount > 0 && networkObject.transform.parent == null)
{
// Get all child NetworkObjects of the root
var childNetworkObjects = networkObject.GetComponentsInChildren<NetworkObject>().ToList();
childNetworkObjects.Sort(SortChildrenNetworkObjects);
// Remove the root from the children list
childNetworkObjects.Remove(networkObject);
// Remove the root's children from the primary list
foreach (var childObject in childNetworkObjects)
{
m_NetworkObjectsSync.Remove(childObject);
}
// Insert or Add the sorted children list
var nextIndex = m_NetworkObjectsSync.IndexOf(networkObject) + 1;
if (nextIndex == m_NetworkObjectsSync.Count)
{
m_NetworkObjectsSync.AddRange(childNetworkObjects);
}
else
{
m_NetworkObjectsSync.InsertRange(nextIndex, childNetworkObjects);
}
}
}
}
internal static bool LogSerializationOrder = false;
internal void AddSpawnedNetworkObjects() internal void AddSpawnedNetworkObjects()
{ {
m_NetworkObjectsSync.Clear(); m_NetworkObjectsSync.Clear();
@@ -256,22 +328,22 @@ namespace Unity.Netcode
} }
} }
// Sort by parents before children
m_NetworkObjectsSync.Sort(SortParentedNetworkObjects);
// Sort by INetworkPrefabInstanceHandler implementation before the // Sort by INetworkPrefabInstanceHandler implementation before the
// NetworkObjects spawned by the implementation // NetworkObjects spawned by the implementation
m_NetworkObjectsSync.Sort(SortNetworkObjects); m_NetworkObjectsSync.Sort(SortNetworkObjects);
// The last thing we sort is parents before children
SortParentedNetworkObjects();
// This is useful to know what NetworkObjects a client is going to be synchronized with // This is useful to know what NetworkObjects a client is going to be synchronized with
// as well as the order in which they will be deserialized // as well as the order in which they will be deserialized
if (m_NetworkManager.LogLevel == LogLevel.Developer) if (LogSerializationOrder && m_NetworkManager.LogLevel == LogLevel.Developer)
{ {
var messageBuilder = new System.Text.StringBuilder(0xFFFF); var messageBuilder = new StringBuilder(0xFFFF);
messageBuilder.Append("[Server-Side Client-Synchronization] NetworkObject serialization order:"); messageBuilder.AppendLine("[Server-Side Client-Synchronization] NetworkObject serialization order:");
foreach (var networkObject in m_NetworkObjectsSync) foreach (var networkObject in m_NetworkObjectsSync)
{ {
messageBuilder.Append($"{networkObject.name}"); messageBuilder.AppendLine($"{networkObject.name}");
} }
NetworkLog.LogInfo(messageBuilder.ToString()); NetworkLog.LogInfo(messageBuilder.ToString());
} }
@@ -362,31 +434,35 @@ namespace Unity.Netcode
return 0; return 0;
} }
/// <summary> internal bool EnableSerializationLogs = false;
/// Sorts the synchronization order of the NetworkObjects to be serialized
/// by parents before children. private void LogArray(byte[] data, int start = 0, int stop = 0, StringBuilder builder = null)
/// </summary>
/// <remarks>
/// This only handles late joining players. Spawning and nesting several children
/// dynamically is still handled by the orphaned child list when deserialized out of
/// hierarchical order (i.e. Spawn parent and child dynamically, parent message is
/// dropped and re-sent but child object is received and processed)
/// </remarks>
private int SortParentedNetworkObjects(NetworkObject first, NetworkObject second)
{ {
// If the first has a parent, move the first down var usingExternalBuilder = builder != null;
if (first.transform.parent != null) if (!usingExternalBuilder)
{ {
return 1; builder = new StringBuilder();
} }
else // If the second has a parent and the first does not, then move the first up
if (second.transform.parent != null) if (stop == 0)
{ {
return -1; stop = data.Length;
}
builder.AppendLine($"[Start Data Dump][Start = {start}][Stop = {stop}] Size ({stop - start})");
for (int i = start; i < stop; i++)
{
builder.Append($"{data[i]:X2} ");
}
builder.Append("\n");
if (!usingExternalBuilder)
{
UnityEngine.Debug.Log(builder.ToString());
} }
return 0;
} }
internal bool ForwardSynchronization;
/// <summary> /// <summary>
/// Client and Server Side: /// Client and Server Side:
@@ -398,6 +474,12 @@ namespace Unity.Netcode
// Write the scene event type // Write the scene event type
writer.WriteValueSafe(SceneEventType); writer.WriteValueSafe(SceneEventType);
if (m_NetworkManager.DistributedAuthorityMode)
{
BytePacker.WriteValueBitPacked(writer, TargetClientId);
BytePacker.WriteValueBitPacked(writer, SenderClientId);
}
if (SceneEventType == SceneEventType.ActiveSceneChanged) if (SceneEventType == SceneEventType.ActiveSceneChanged)
{ {
writer.WriteValueSafe(ActiveSceneHash); writer.WriteValueSafe(ActiveSceneHash);
@@ -432,12 +514,25 @@ namespace Unity.Netcode
case SceneEventType.Synchronize: case SceneEventType.Synchronize:
{ {
writer.WriteValueSafe(ActiveSceneHash); writer.WriteValueSafe(ActiveSceneHash);
WriteSceneSynchronizationData(writer); WriteSceneSynchronizationData(writer);
if (EnableSerializationLogs)
{
LogArray(writer.ToArray(), 0, writer.Length);
}
break; break;
} }
case SceneEventType.Load: case SceneEventType.Load:
{ {
SerializeScenePlacedObjects(writer); if (m_NetworkManager.DistributedAuthorityMode && IsForwarding && m_NetworkManager.DAHost)
{
CopyInternalBuffer(ref writer);
}
else
{
SerializeScenePlacedObjects(writer);
}
break; break;
} }
case SceneEventType.SynchronizeComplete: case SceneEventType.SynchronizeComplete:
@@ -459,6 +554,11 @@ namespace Unity.Netcode
} }
} }
private unsafe void CopyInternalBuffer(ref FastBufferWriter writer)
{
writer.WriteBytesSafe(InternalBuffer.GetUnsafePtrAtCurrentPosition(), InternalBuffer.Length);
}
/// <summary> /// <summary>
/// Server Side: /// Server Side:
/// Called at the end of a <see cref="SceneEventType.Load"/> event once the scene is loaded and scene placed NetworkObjects /// Called at the end of a <see cref="SceneEventType.Load"/> event once the scene is loaded and scene placed NetworkObjects
@@ -466,13 +566,29 @@ namespace Unity.Netcode
/// </summary> /// </summary>
internal void WriteSceneSynchronizationData(FastBufferWriter writer) internal void WriteSceneSynchronizationData(FastBufferWriter writer)
{ {
var builder = (StringBuilder)null;
if (EnableSerializationLogs)
{
builder = new StringBuilder();
builder.AppendLine($"[Write][Synchronize-Start][WPos: {writer.Position}] Begin:");
}
// Write the scenes we want to load, in the order we want to load them // Write the scenes we want to load, in the order we want to load them
writer.WriteValueSafe(ScenesToSynchronize.ToArray()); writer.WriteValueSafe(ScenesToSynchronize.ToArray());
writer.WriteValueSafe(SceneHandlesToSynchronize.ToArray()); writer.WriteValueSafe(SceneHandlesToSynchronize.ToArray());
// Store our current position in the stream to come back and say how much data we have written // Store our current position in the stream to come back and say how much data we have written
var positionStart = writer.Position; var positionStart = writer.Position;
if (m_NetworkManager.DistributedAuthorityMode && ForwardSynchronization && m_NetworkManager.DAHost)
{
writer.WriteValueSafe(m_InternalBufferSize);
CopyInternalBuffer(ref writer);
if (EnableSerializationLogs)
{
LogArray(writer.ToArray(), positionStart);
}
return;
}
// Size Place Holder -- Start // Size Place Holder -- Start
// !!NOTE!!: Since this is a placeholder to be set after we know how much we have written, // !!NOTE!!: Since this is a placeholder to be set after we know how much we have written,
// for stream offset purposes this MUST not be a packed value! // for stream offset purposes this MUST not be a packed value!
@@ -481,15 +597,34 @@ namespace Unity.Netcode
// Write the number of NetworkObjects we are serializing // Write the number of NetworkObjects we are serializing
writer.WriteValueSafe(m_NetworkObjectsSync.Count); writer.WriteValueSafe(m_NetworkObjectsSync.Count);
if (EnableSerializationLogs)
{
builder.AppendLine($"[Synchronize Objects][positionStart: {positionStart}][WPos: {writer.Position}][NO-Count: {m_NetworkObjectsSync.Count}] Begin:");
}
var distributedAuthority = m_NetworkManager.DistributedAuthorityMode;
// Serialize all NetworkObjects that are spawned // Serialize all NetworkObjects that are spawned
for (var i = 0; i < m_NetworkObjectsSync.Count; ++i) for (var i = 0; i < m_NetworkObjectsSync.Count; ++i)
{ {
var networkObject = m_NetworkObjectsSync[i];
var noStart = writer.Position; var noStart = writer.Position;
var sceneObject = m_NetworkObjectsSync[i].GetMessageSceneObject(TargetClientId); // In distributed authority mode, we send the currently known observers of each NetworkObject to the client being synchronized.
var sceneObject = m_NetworkObjectsSync[i].GetMessageSceneObject(TargetClientId, distributedAuthority);
sceneObject.Serialize(writer); sceneObject.Serialize(writer);
var noStop = writer.Position; var noStop = writer.Position;
totalBytes += noStop - noStart; totalBytes += noStop - noStart;
if (EnableSerializationLogs)
{
var offStart = noStart - (positionStart + sizeof(int));
var offStop = noStop - (positionStart + sizeof(int));
builder.AppendLine($"[Head: {offStart}][Tail: {offStop}][Size: {offStop - offStart}][{networkObject.name}][NID-{networkObject.NetworkObjectId}][Children: {networkObject.ChildNetworkBehaviours.Count}]");
LogArray(writer.ToArray(), noStart, noStop, builder);
}
}
if (EnableSerializationLogs)
{
UnityEngine.Debug.Log(builder.ToString());
} }
// Write the number of despawned in-scene placed NetworkObjects // Write the number of despawned in-scene placed NetworkObjects
@@ -511,6 +646,10 @@ namespace Unity.Netcode
// Write the total size written to the stream by NetworkObjects being serialized // Write the total size written to the stream by NetworkObjects being serialized
writer.WriteValueSafe(bytesWritten); writer.WriteValueSafe(bytesWritten);
writer.Seek(positionEnd); writer.Seek(positionEnd);
if (EnableSerializationLogs)
{
LogArray(writer.ToArray(), positionStart);
}
} }
/// <summary> /// <summary>
@@ -526,6 +665,7 @@ namespace Unity.Netcode
// Write our count place holder (must not be packed!) // Write our count place holder (must not be packed!)
writer.WriteValueSafe((ushort)0); writer.WriteValueSafe((ushort)0);
var distributedAuthority = m_NetworkManager.DistributedAuthorityMode;
foreach (var keyValuePairByGlobalObjectIdHash in m_NetworkManager.SceneManager.ScenePlacedObjects) foreach (var keyValuePairByGlobalObjectIdHash in m_NetworkManager.SceneManager.ScenePlacedObjects)
{ {
@@ -534,7 +674,7 @@ namespace Unity.Netcode
if (keyValuePairBySceneHandle.Value.Observers.Contains(TargetClientId)) if (keyValuePairBySceneHandle.Value.Observers.Contains(TargetClientId))
{ {
// Serialize the NetworkObject // Serialize the NetworkObject
var sceneObject = keyValuePairBySceneHandle.Value.GetMessageSceneObject(TargetClientId); var sceneObject = keyValuePairBySceneHandle.Value.GetMessageSceneObject(TargetClientId, distributedAuthority);
sceneObject.Serialize(writer); sceneObject.Serialize(writer);
numberOfObjects++; numberOfObjects++;
} }
@@ -567,6 +707,12 @@ namespace Unity.Netcode
internal void Deserialize(FastBufferReader reader) internal void Deserialize(FastBufferReader reader)
{ {
reader.ReadValueSafe(out SceneEventType); reader.ReadValueSafe(out SceneEventType);
if (m_NetworkManager.DistributedAuthorityMode)
{
ByteUnpacker.ReadValueBitPacked(reader, out TargetClientId);
ByteUnpacker.ReadValueBitPacked(reader, out SenderClientId);
}
if (SceneEventType == SceneEventType.ActiveSceneChanged) if (SceneEventType == SceneEventType.ActiveSceneChanged)
{ {
reader.ReadValueSafe(out ActiveSceneHash); reader.ReadValueSafe(out ActiveSceneHash);
@@ -607,6 +753,10 @@ namespace Unity.Netcode
case SceneEventType.Synchronize: case SceneEventType.Synchronize:
{ {
reader.ReadValueSafe(out ActiveSceneHash); reader.ReadValueSafe(out ActiveSceneHash);
if (EnableSerializationLogs)
{
LogArray(reader.ToArray(), 0, reader.Length);
}
CopySceneSynchronizationData(reader); CopySceneSynchronizationData(reader);
break; break;
} }
@@ -641,6 +791,8 @@ namespace Unity.Netcode
} }
} }
private int m_InternalBufferSize;
/// <summary> /// <summary>
/// Client Side: /// Client Side:
/// Prepares for a scene synchronization event and copies the scene synchronization data /// Prepares for a scene synchronization event and copies the scene synchronization data
@@ -657,6 +809,8 @@ namespace Unity.Netcode
// is not packed! // is not packed!
reader.ReadValueSafe(out int sizeToCopy); reader.ReadValueSafe(out int sizeToCopy);
m_InternalBufferSize = sizeToCopy;
unsafe unsafe
{ {
if (!reader.TryBeginRead(sizeToCopy)) if (!reader.TryBeginRead(sizeToCopy))
@@ -667,6 +821,10 @@ namespace Unity.Netcode
m_HasInternalBuffer = true; m_HasInternalBuffer = true;
// We use Allocator.Persistent since scene synchronization will most likely take longer than 4 frames // We use Allocator.Persistent since scene synchronization will most likely take longer than 4 frames
InternalBuffer = new FastBufferReader(reader.GetUnsafePtrAtCurrentPosition(), Allocator.Persistent, sizeToCopy); InternalBuffer = new FastBufferReader(reader.GetUnsafePtrAtCurrentPosition(), Allocator.Persistent, sizeToCopy);
if (EnableSerializationLogs)
{
LogArray(InternalBuffer.ToArray());
}
} }
} }
@@ -916,12 +1074,24 @@ namespace Unity.Netcode
/// <param name="networkManager"></param> /// <param name="networkManager"></param>
internal void SynchronizeSceneNetworkObjects(NetworkManager networkManager) internal void SynchronizeSceneNetworkObjects(NetworkManager networkManager)
{ {
var builder = (StringBuilder)null;
if (EnableSerializationLogs)
{
builder = new StringBuilder();
}
try try
{ {
// Process all spawned NetworkObjects for this network session // Process all spawned NetworkObjects for this network session
InternalBuffer.ReadValueSafe(out int newObjectsCount); InternalBuffer.ReadValueSafe(out int newObjectsCount);
if (EnableSerializationLogs)
{
builder.AppendLine($"[Read][Synchronize Objects][WPos: {InternalBuffer.Position}][NO-Count: {newObjectsCount}] Begin:");
}
for (int i = 0; i < newObjectsCount; i++) for (int i = 0; i < newObjectsCount; i++)
{ {
var noStart = InternalBuffer.Position;
var sceneObject = new NetworkObject.SceneObject(); var sceneObject = new NetworkObject.SceneObject();
sceneObject.Deserialize(InternalBuffer); sceneObject.Deserialize(InternalBuffer);
@@ -932,6 +1102,12 @@ namespace Unity.Netcode
} }
var spawnedNetworkObject = NetworkObject.AddSceneObject(sceneObject, InternalBuffer, networkManager); var spawnedNetworkObject = NetworkObject.AddSceneObject(sceneObject, InternalBuffer, networkManager);
var noStop = InternalBuffer.Position;
if (EnableSerializationLogs)
{
builder.AppendLine($"[Head: {noStart}][Tail: {noStop}][Size: {noStop - noStart}][{spawnedNetworkObject.name}][NID-{spawnedNetworkObject.NetworkObjectId}][Children: {spawnedNetworkObject.ChildNetworkBehaviours.Count}]");
LogArray(InternalBuffer.ToArray(), noStart, noStop, builder);
}
// If we failed to deserialize the NetowrkObject then don't add null to the list // If we failed to deserialize the NetowrkObject then don't add null to the list
if (spawnedNetworkObject != null) if (spawnedNetworkObject != null)
{ {
@@ -941,11 +1117,20 @@ namespace Unity.Netcode
} }
} }
} }
if (EnableSerializationLogs)
{
UnityEngine.Debug.Log(builder.ToString());
}
// Now deserialize the despawned in-scene placed NetworkObjects list (if any) // Now deserialize the despawned in-scene placed NetworkObjects list (if any)
DeserializeDespawnedInScenePlacedNetworkObjects(); DeserializeDespawnedInScenePlacedNetworkObjects();
} }
catch (Exception ex)
{
UnityEngine.Debug.LogException(ex);
UnityEngine.Debug.Log(builder.ToString());
}
finally finally
{ {
InternalBuffer.Dispose(); InternalBuffer.Dispose();
@@ -999,24 +1184,38 @@ namespace Unity.Netcode
/// Serialize scene handles and associated NetworkObjects that were migrated /// Serialize scene handles and associated NetworkObjects that were migrated
/// into a new scene. /// into a new scene.
/// </summary> /// </summary>
internal bool IsForwarding;
private ulong m_OwnerId;
private void SerializeObjectsMovedIntoNewScene(FastBufferWriter writer) private void SerializeObjectsMovedIntoNewScene(FastBufferWriter writer)
{ {
var sceneManager = m_NetworkManager.SceneManager; var sceneManager = m_NetworkManager.SceneManager;
var ownerId = m_NetworkManager.LocalClientId;
if (IsForwarding)
{
ownerId = m_OwnerId;
}
// Write the owner identifier
writer.WriteValueSafe(ownerId);
// Write the number of scene handles // Write the number of scene handles
writer.WriteValueSafe(sceneManager.ObjectsMigratedIntoNewScene.Count); writer.WriteValueSafe(sceneManager.ObjectsMigratedIntoNewScene.Count);
foreach (var sceneHandleObjects in sceneManager.ObjectsMigratedIntoNewScene) foreach (var sceneHandleObjects in sceneManager.ObjectsMigratedIntoNewScene)
{ {
if (!sceneManager.ObjectsMigratedIntoNewScene[sceneHandleObjects.Key].ContainsKey(ownerId))
{
throw new Exception($"Trying to send object scene migration for Client-{ownerId} but the client has no entries to send!");
}
// Write the scene handle // Write the scene handle
writer.WriteValueSafe(sceneHandleObjects.Key); writer.WriteValueSafe(sceneHandleObjects.Key);
// Write the number of NetworkObjectIds to expect // Write the number of NetworkObjectIds to expect
writer.WriteValueSafe(sceneHandleObjects.Value.Count); writer.WriteValueSafe(sceneHandleObjects.Value[ownerId].Count);
foreach (var networkObject in sceneHandleObjects.Value) foreach (var networkObject in sceneHandleObjects.Value[ownerId])
{ {
writer.WriteValueSafe(networkObject.NetworkObjectId); writer.WriteValueSafe(networkObject.NetworkObjectId);
} }
} }
// Once we are done, clear the table
sceneManager.ObjectsMigratedIntoNewScene.Clear();
} }
/// <summary> /// <summary>
@@ -1027,17 +1226,30 @@ namespace Unity.Netcode
{ {
var sceneManager = m_NetworkManager.SceneManager; var sceneManager = m_NetworkManager.SceneManager;
var spawnManager = m_NetworkManager.SpawnManager; var spawnManager = m_NetworkManager.SpawnManager;
// Just always assure this has no entries
sceneManager.ObjectsMigratedIntoNewScene.Clear();
var numberOfScenes = 0; var numberOfScenes = 0;
var sceneHandle = 0; var sceneHandle = 0;
var objectCount = 0; var objectCount = 0;
var networkObjectId = (ulong)0; var networkObjectId = (ulong)0;
var ownerID = (ulong)0;
reader.ReadValueSafe(out ownerID);
m_OwnerId = ownerID;
reader.ReadValueSafe(out numberOfScenes); reader.ReadValueSafe(out numberOfScenes);
for (int i = 0; i < numberOfScenes; i++) for (int i = 0; i < numberOfScenes; i++)
{ {
reader.ReadValueSafe(out sceneHandle); reader.ReadValueSafe(out sceneHandle);
sceneManager.ObjectsMigratedIntoNewScene.Add(sceneHandle, new List<NetworkObject>()); if (!sceneManager.ObjectsMigratedIntoNewScene.ContainsKey(sceneHandle))
{
sceneManager.ObjectsMigratedIntoNewScene.Add(sceneHandle, new Dictionary<ulong, List<NetworkObject>>());
}
if (!sceneManager.ObjectsMigratedIntoNewScene[sceneHandle].ContainsKey(ownerID))
{
sceneManager.ObjectsMigratedIntoNewScene[sceneHandle].Add(ownerID, new List<NetworkObject>());
}
reader.ReadValueSafe(out objectCount); reader.ReadValueSafe(out objectCount);
for (int j = 0; j < objectCount; j++) for (int j = 0; j < objectCount; j++)
{ {
@@ -1047,9 +1259,9 @@ namespace Unity.Netcode
NetworkLog.LogError($"[Object Scene Migration] Trying to synchronize NetworkObjectId ({networkObjectId}) but it was not spawned or no longer exists!!"); NetworkLog.LogError($"[Object Scene Migration] Trying to synchronize NetworkObjectId ({networkObjectId}) but it was not spawned or no longer exists!!");
continue; continue;
} }
var networkObject = spawnManager.SpawnedObjects[networkObjectId];
// Add NetworkObject scene migration to ObjectsMigratedIntoNewScene dictionary that is processed // Add NetworkObject scene migration to ObjectsMigratedIntoNewScene dictionary that is processed
// sceneManager.ObjectsMigratedIntoNewScene[sceneHandle][ownerID].Add(networkObject);
sceneManager.ObjectsMigratedIntoNewScene[sceneHandle].Add(spawnManager.SpawnedObjects[networkObjectId]);
} }
} }
} }
@@ -1065,16 +1277,22 @@ namespace Unity.Netcode
{ {
var sceneManager = m_NetworkManager.SceneManager; var sceneManager = m_NetworkManager.SceneManager;
var spawnManager = m_NetworkManager.SpawnManager; var spawnManager = m_NetworkManager.SpawnManager;
var ownerId = (ulong)0;
var numberOfScenes = 0; var numberOfScenes = 0;
var sceneHandle = 0; var sceneHandle = 0;
var objectCount = 0; var objectCount = 0;
var networkObjectId = (ulong)0; var networkObjectId = (ulong)0;
reader.ReadValueSafe(out ownerId);
var deferredObjectsMovedEvent = new NetworkSceneManager.DeferredObjectsMovedEvent() var deferredObjectsMovedEvent = new NetworkSceneManager.DeferredObjectsMovedEvent()
{ {
ObjectsMigratedTable = new Dictionary<int, List<ulong>>() OwnerId = ownerId,
ObjectsMigratedTable = new Dictionary<int, List<ulong>>(),
}; };
reader.ReadValueSafe(out numberOfScenes); reader.ReadValueSafe(out numberOfScenes);
for (int i = 0; i < numberOfScenes; i++) for (int i = 0; i < numberOfScenes; i++)
{ {
@@ -1104,8 +1322,13 @@ namespace Unity.Netcode
{ {
if (!sceneManager.ObjectsMigratedIntoNewScene.ContainsKey(keyEntry.Key)) if (!sceneManager.ObjectsMigratedIntoNewScene.ContainsKey(keyEntry.Key))
{ {
sceneManager.ObjectsMigratedIntoNewScene.Add(keyEntry.Key, new List<NetworkObject>()); sceneManager.ObjectsMigratedIntoNewScene.Add(keyEntry.Key, new Dictionary<ulong, List<NetworkObject>>());
} }
if (!sceneManager.ObjectsMigratedIntoNewScene[keyEntry.Key].ContainsKey(objectsMovedEvent.OwnerId))
{
sceneManager.ObjectsMigratedIntoNewScene[keyEntry.Key].Add(objectsMovedEvent.OwnerId, new List<NetworkObject>());
}
foreach (var objectId in keyEntry.Value) foreach (var objectId in keyEntry.Value)
{ {
if (!spawnManager.SpawnedObjects.ContainsKey(objectId)) if (!spawnManager.SpawnedObjects.ContainsKey(objectId))
@@ -1114,22 +1337,15 @@ namespace Unity.Netcode
continue; continue;
} }
var networkObject = spawnManager.SpawnedObjects[objectId]; var networkObject = spawnManager.SpawnedObjects[objectId];
if (!sceneManager.ObjectsMigratedIntoNewScene[keyEntry.Key].Contains(networkObject)) if (!sceneManager.ObjectsMigratedIntoNewScene[keyEntry.Key][objectsMovedEvent.OwnerId].Contains(networkObject))
{ {
sceneManager.ObjectsMigratedIntoNewScene[keyEntry.Key].Add(networkObject); sceneManager.ObjectsMigratedIntoNewScene[keyEntry.Key][objectsMovedEvent.OwnerId].Add(networkObject);
} }
} }
} }
objectsMovedEvent.ObjectsMigratedTable.Clear(); objectsMovedEvent.ObjectsMigratedTable.Clear();
} }
sceneManager.DeferredObjectsMovedEvents.Clear(); sceneManager.DeferredObjectsMovedEvents.Clear();
// If there are any pending objects to migrate, then migrate them
if (sceneManager.ObjectsMigratedIntoNewScene.Count > 0)
{
sceneManager.MigrateNetworkObjectsIntoScenes();
}
} }
/// <summary> /// <summary>

16
Runtime/SceneManagement/SceneEventProgress.cs
View File

@@ -55,6 +55,10 @@ namespace Unity.Netcode
/// This is returned when a client attempts to perform a server only action /// This is returned when a client attempts to perform a server only action
/// </summary> /// </summary>
ServerOnlyAction, ServerOnlyAction,
/// <summary>
/// This is returned when a client that is not the session owner attempts to perform a session owner only action
/// </summary>
SessionOwnerOnlyAction,
} }
/// <summary> /// <summary>
@@ -157,22 +161,20 @@ namespace Unity.Netcode
if (status == SceneEventProgressStatus.Started) if (status == SceneEventProgressStatus.Started)
{ {
m_NetworkManager = networkManager; m_NetworkManager = networkManager;
WhenSceneEventHasTimedOut = networkManager.RealTimeProvider.RealTimeSinceStartup + networkManager.NetworkConfig.LoadSceneTimeOut;
if (networkManager.IsServer) if ((networkManager.IsServer && !networkManager.DistributedAuthorityMode) || (networkManager.DistributedAuthorityMode && networkManager.LocalClient.IsSessionOwner))
{ {
m_NetworkManager.OnClientDisconnectCallback += OnClientDisconnectCallback; m_NetworkManager.OnClientDisconnectCallback += OnClientDisconnectCallback;
// Track the clients that were connected when we started this event // Track the clients that were connected when we started this event
foreach (var connectedClientId in networkManager.ConnectedClientsIds) foreach (var connectedClientId in networkManager.ConnectedClientsIds)
{ {
// Ignore the host client // Ignore the host or session owner
if (NetworkManager.ServerClientId == connectedClientId) if ((!networkManager.DistributedAuthorityMode && NetworkManager.ServerClientId == connectedClientId) || (networkManager.DistributedAuthorityMode && networkManager.CurrentSessionOwner == connectedClientId))
{ {
continue; continue;
} }
ClientsProcessingSceneEvent.Add(connectedClientId, false); ClientsProcessingSceneEvent.Add(connectedClientId, false);
} }
WhenSceneEventHasTimedOut = networkManager.RealTimeProvider.RealTimeSinceStartup + networkManager.NetworkConfig.LoadSceneTimeOut;
m_TimeOutCoroutine = m_NetworkManager.StartCoroutine(TimeOutSceneEventProgress()); m_TimeOutCoroutine = m_NetworkManager.StartCoroutine(TimeOutSceneEventProgress());
} }
} }
@@ -298,7 +300,7 @@ namespace Unity.Netcode
m_NetworkManager.OnClientDisconnectCallback -= OnClientDisconnectCallback; m_NetworkManager.OnClientDisconnectCallback -= OnClientDisconnectCallback;
} }
if (m_TimeOutCoroutine != null) if (m_TimeOutCoroutine != null && m_NetworkManager != null)
{ {
m_NetworkManager.StopCoroutine(m_TimeOutCoroutine); m_NetworkManager.StopCoroutine(m_TimeOutCoroutine);
} }

35
Runtime/Serialization/FastBufferReader.cs
View File

@@ -245,6 +245,11 @@ namespace Unity.Netcode
/// </summary> /// </summary>
public unsafe void Dispose() public unsafe void Dispose()
{ {
if (Handle == null)
{
return;
}
UnsafeUtility.Free(Handle, Handle->Allocator); UnsafeUtility.Free(Handle, Handle->Allocator);
Handle = null; Handle = null;
} }
@@ -1069,6 +1074,36 @@ namespace Unity.Netcode
ReadUnmanagedSafeInPlace(ref value); ReadUnmanagedSafeInPlace(ref value);
} }
} }
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal void ReadValueSafeInPlace<T>(ref NativeHashSet<T> value) where T : unmanaged, IEquatable<T>
{
ReadUnmanagedSafe(out int length);
value.Clear();
for (var i = 0; i < length; ++i)
{
T val = default;
NetworkVariableSerialization<T>.Read(this, ref val);
value.Add(val);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal void ReadValueSafeInPlace<TKey, TVal>(ref NativeHashMap<TKey, TVal> value)
where TKey : unmanaged, IEquatable<TKey>
where TVal : unmanaged
{
ReadUnmanagedSafe(out int length);
value.Clear();
for (var i = 0; i < length; ++i)
{
TKey key = default;
TVal val = default;
NetworkVariableSerialization<TKey>.Read(this, ref key);
NetworkVariableSerialization<TVal>.Read(this, ref val);
value[key] = val;
}
}
#endif #endif
/// <summary> /// <summary>

49
Runtime/Serialization/FastBufferWriter.cs
View File

@@ -772,7 +772,11 @@ namespace Unity.Netcode
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe void WriteBytes(NativeList<byte> value, int size = -1, int offset = 0) public unsafe void WriteBytes(NativeList<byte> value, int size = -1, int offset = 0)
{ {
#if UTP_TRANSPORT_2_0_ABOVE
byte* ptr = value.GetUnsafePtr();
#else
byte* ptr = (byte*)value.GetUnsafePtr(); byte* ptr = (byte*)value.GetUnsafePtr();
#endif
WriteBytes(ptr, size == -1 ? value.Length : size, offset); WriteBytes(ptr, size == -1 ? value.Length : size, offset);
} }
@@ -816,7 +820,11 @@ namespace Unity.Netcode
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe void WriteBytesSafe(NativeList<byte> value, int size = -1, int offset = 0) public unsafe void WriteBytesSafe(NativeList<byte> value, int size = -1, int offset = 0)
{ {
#if UTP_TRANSPORT_2_0_ABOVE
byte* ptr = value.GetUnsafePtr();
#else
byte* ptr = (byte*)value.GetUnsafePtr(); byte* ptr = (byte*)value.GetUnsafePtr();
#endif
WriteBytesSafe(ptr, size == -1 ? value.Length : size, offset); WriteBytesSafe(ptr, size == -1 ? value.Length : size, offset);
} }
@@ -985,7 +993,11 @@ namespace Unity.Netcode
internal unsafe void WriteUnmanaged<T>(NativeList<T> value) where T : unmanaged internal unsafe void WriteUnmanaged<T>(NativeList<T> value) where T : unmanaged
{ {
WriteUnmanaged(value.Length); WriteUnmanaged(value.Length);
#if UTP_TRANSPORT_2_0_ABOVE
var ptr = value.GetUnsafePtr();
#else
var ptr = (T*)value.GetUnsafePtr(); var ptr = (T*)value.GetUnsafePtr();
#endif
{ {
byte* bytes = (byte*)ptr; byte* bytes = (byte*)ptr;
WriteBytes(bytes, sizeof(T) * value.Length); WriteBytes(bytes, sizeof(T) * value.Length);
@@ -995,7 +1007,11 @@ namespace Unity.Netcode
internal unsafe void WriteUnmanagedSafe<T>(NativeList<T> value) where T : unmanaged internal unsafe void WriteUnmanagedSafe<T>(NativeList<T> value) where T : unmanaged
{ {
WriteUnmanagedSafe(value.Length); WriteUnmanagedSafe(value.Length);
#if UTP_TRANSPORT_2_0_ABOVE
var ptr = value.GetUnsafePtr();
#else
var ptr = (T*)value.GetUnsafePtr(); var ptr = (T*)value.GetUnsafePtr();
#endif
{ {
byte* bytes = (byte*)ptr; byte* bytes = (byte*)ptr;
WriteBytesSafe(bytes, sizeof(T) * value.Length); WriteBytesSafe(bytes, sizeof(T) * value.Length);
@@ -1189,6 +1205,39 @@ namespace Unity.Netcode
WriteUnmanaged(value); WriteUnmanaged(value);
} }
} }
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal void WriteValueSafe<T>(NativeHashSet<T> value) where T : unmanaged, IEquatable<T>
{
#if UTP_TRANSPORT_2_0_ABOVE
WriteUnmanagedSafe(value.Count);
#else
WriteUnmanagedSafe(value.Count());
#endif
foreach (var item in value)
{
var iReffable = item;
NetworkVariableSerialization<T>.Write(this, ref iReffable);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal void WriteValueSafe<TKey, TVal>(NativeHashMap<TKey, TVal> value)
where TKey : unmanaged, IEquatable<TKey>
where TVal : unmanaged
{
#if UTP_TRANSPORT_2_0_ABOVE
WriteUnmanagedSafe(value.Count);
#else
WriteUnmanagedSafe(value.Count());
#endif
foreach (var item in value)
{
(var key, var val) = (item.Key, item.Value);
NetworkVariableSerialization<TKey>.Write(this, ref key);
NetworkVariableSerialization<TVal>.Write(this, ref val);
}
}
#endif #endif
/// <summary> /// <summary>

4
Runtime/Serialization/NetworkBehaviourReference.cs
View File

@@ -40,7 +40,7 @@ namespace Unity.Netcode
/// <returns>True if the <see cref="NetworkBehaviour"/> was found; False if the <see cref="NetworkBehaviour"/> was not found. This can happen if the corresponding <see cref="NetworkObject"/> has not been spawned yet. you can try getting the reference at a later point in time.</returns> /// <returns>True if the <see cref="NetworkBehaviour"/> was found; False if the <see cref="NetworkBehaviour"/> was not found. This can happen if the corresponding <see cref="NetworkObject"/> has not been spawned yet. you can try getting the reference at a later point in time.</returns>
public bool TryGet(out NetworkBehaviour networkBehaviour, NetworkManager networkManager = null) public bool TryGet(out NetworkBehaviour networkBehaviour, NetworkManager networkManager = null)
{ {
networkBehaviour = GetInternal(this, null); networkBehaviour = GetInternal(this, networkManager);
return networkBehaviour != null; return networkBehaviour != null;
} }
@@ -53,7 +53,7 @@ namespace Unity.Netcode
/// <returns>True if the <see cref="NetworkBehaviour"/> was found; False if the <see cref="NetworkBehaviour"/> was not found. This can happen if the corresponding <see cref="NetworkObject"/> has not been spawned yet. you can try getting the reference at a later point in time.</returns> /// <returns>True if the <see cref="NetworkBehaviour"/> was found; False if the <see cref="NetworkBehaviour"/> was not found. This can happen if the corresponding <see cref="NetworkObject"/> has not been spawned yet. you can try getting the reference at a later point in time.</returns>
public bool TryGet<T>(out T networkBehaviour, NetworkManager networkManager = null) where T : NetworkBehaviour public bool TryGet<T>(out T networkBehaviour, NetworkManager networkManager = null) where T : NetworkBehaviour
{ {
networkBehaviour = GetInternal(this, null) as T; networkBehaviour = GetInternal(this, networkManager) as T;
return networkBehaviour != null; return networkBehaviour != null;
} }

962
Runtime/Spawning/NetworkSpawnManager.cs
View File

File diff suppressed because it is too large Load Diff

1
Runtime/Timing/IRealTimeProvider.cs
View File

@@ -6,5 +6,6 @@ namespace Unity.Netcode
float UnscaledTime { get; } float UnscaledTime { get; }
float UnscaledDeltaTime { get; } float UnscaledDeltaTime { get; }
float DeltaTime { get; } float DeltaTime { get; }
float FixedDeltaTime { get; }
} }
} }

4
Runtime/Timing/NetworkTime.cs
View File

@@ -113,9 +113,9 @@ namespace Unity.Netcode
/// </summary> /// </summary>
/// <param name="ticks">The number of ticks ago we're querying the time</param> /// <param name="ticks">The number of ticks ago we're querying the time</param>
/// <returns></returns> /// <returns></returns>
public NetworkTime TimeTicksAgo(int ticks) public NetworkTime TimeTicksAgo(int ticks, float offset = 0.0f)
{ {
return this - new NetworkTime(TickRate, ticks); return this - new NetworkTime(TickRate, ticks, offset);
} }
private void UpdateCache() private void UpdateCache()

1
Runtime/Timing/RealTimeProvider.cs
View File

@@ -8,5 +8,6 @@ namespace Unity.Netcode
public float UnscaledTime => Time.unscaledTime; public float UnscaledTime => Time.unscaledTime;
public float UnscaledDeltaTime => Time.unscaledDeltaTime; public float UnscaledDeltaTime => Time.unscaledDeltaTime;
public float DeltaTime => Time.deltaTime; public float DeltaTime => Time.deltaTime;
public float FixedDeltaTime => Time.fixedDeltaTime;
} }
} }

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

@@ -106,7 +106,11 @@ namespace Unity.Netcode.Transports.UTP
{ {
unsafe unsafe
{ {
#if UTP_TRANSPORT_2_0_ABOVE
var writer = new DataStreamWriter(m_Data.GetUnsafePtr() + TailIndex, Capacity - TailIndex);
#else
var writer = new DataStreamWriter((byte*)m_Data.GetUnsafePtr() + TailIndex, Capacity - TailIndex); var writer = new DataStreamWriter((byte*)m_Data.GetUnsafePtr() + TailIndex, Capacity - TailIndex);
#endif
writer.WriteInt(data.Count); writer.WriteInt(data.Count);
@@ -145,7 +149,11 @@ namespace Unity.Netcode.Transports.UTP
{ {
unsafe unsafe
{ {
#if UTP_TRANSPORT_2_0_ABOVE
UnsafeUtility.MemMove(m_Data.GetUnsafePtr(), m_Data.GetUnsafePtr() + HeadIndex, Length);
#else
UnsafeUtility.MemMove(m_Data.GetUnsafePtr(), (byte*)m_Data.GetUnsafePtr() + HeadIndex, Length); UnsafeUtility.MemMove(m_Data.GetUnsafePtr(), (byte*)m_Data.GetUnsafePtr() + HeadIndex, Length);
#endif
} }
TailIndex = Length; TailIndex = Length;
@@ -231,7 +239,11 @@ namespace Unity.Netcode.Transports.UTP
if (bytesToWrite > softMaxBytes && bytesToWrite <= writer.Capacity) if (bytesToWrite > softMaxBytes && bytesToWrite <= writer.Capacity)
{ {
writer.WriteInt(messageLength); writer.WriteInt(messageLength);
#if UTP_TRANSPORT_2_0_ABOVE
WriteBytes(ref writer, m_Data.GetUnsafePtr() + reader.GetBytesRead(), messageLength);
#else
WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + reader.GetBytesRead(), messageLength); WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + reader.GetBytesRead(), messageLength);
#endif
return bytesToWrite; return bytesToWrite;
} }
@@ -248,7 +260,11 @@ namespace Unity.Netcode.Transports.UTP
if (bytesWritten + bytesToWrite <= softMaxBytes) if (bytesWritten + bytesToWrite <= softMaxBytes)
{ {
writer.WriteInt(messageLength); writer.WriteInt(messageLength);
#if UTP_TRANSPORT_2_0_ABOVE
WriteBytes(ref writer, m_Data.GetUnsafePtr() + reader.GetBytesRead(), messageLength);
#else
WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + reader.GetBytesRead(), messageLength); WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + reader.GetBytesRead(), messageLength);
#endif
readerOffset += bytesToWrite; readerOffset += bytesToWrite;
bytesWritten += bytesToWrite; bytesWritten += bytesToWrite;
@@ -292,7 +308,11 @@ namespace Unity.Netcode.Transports.UTP
unsafe unsafe
{ {
#if UTP_TRANSPORT_2_0_ABOVE
WriteBytes(ref writer, m_Data.GetUnsafePtr() + HeadIndex, copyLength);
#else
WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + HeadIndex, copyLength); WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + HeadIndex, copyLength);
#endif
} }
return copyLength; return copyLength;

31
TestHelpers/Runtime/IntegrationTestSceneHandler.cs
View File

@@ -23,6 +23,8 @@ namespace Unity.Netcode.TestHelpers.Runtime
public Scene Scene; public Scene Scene;
} }
public bool IsIntegrationTest() { return true; }
internal static Dictionary<NetworkManager, Dictionary<string, Dictionary<int, SceneEntry>>> SceneNameToSceneHandles = new Dictionary<NetworkManager, Dictionary<string, Dictionary<int, SceneEntry>>>(); internal static Dictionary<NetworkManager, Dictionary<string, Dictionary<int, SceneEntry>>> SceneNameToSceneHandles = new Dictionary<NetworkManager, Dictionary<string, Dictionary<int, SceneEntry>>>();
// All IntegrationTestSceneHandler instances register their associated NetworkManager // All IntegrationTestSceneHandler instances register their associated NetworkManager
@@ -165,13 +167,30 @@ namespace Unity.Netcode.TestHelpers.Runtime
foreach (var sobj in inSceneNetworkObjects) foreach (var sobj in inSceneNetworkObjects)
{ {
if (sobj.NetworkManagerOwner != networkManager) ProcessInSceneObject(sobj, networkManager);
}
}
/// <summary>
/// Assures to apply an ObjectNameIdentifier to all children
/// </summary>
private static void ProcessInSceneObject(NetworkObject networkObject, NetworkManager networkManager)
{
if (networkObject.NetworkManagerOwner != networkManager)
{
networkObject.NetworkManagerOwner = networkManager;
}
if (networkObject.GetComponent<ObjectNameIdentifier>() == null)
{
networkObject.gameObject.AddComponent<ObjectNameIdentifier>();
var networkObjects = networkObject.gameObject.GetComponentsInChildren<NetworkObject>();
foreach (var child in networkObjects)
{ {
sobj.NetworkManagerOwner = networkManager; if (child == networkObject)
} {
if (sobj.GetComponent<ObjectNameIdentifier>() == null && sobj.GetComponentInChildren<ObjectNameIdentifier>() == null) continue;
{ }
sobj.gameObject.AddComponent<ObjectNameIdentifier>(); ProcessInSceneObject(child, networkManager);
} }
} }
} }

29
TestHelpers/Runtime/IntegrationTestWithApproximation.cs
View File

@@ -1,12 +1,24 @@
using System;
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
using UnityEngine; using UnityEngine;
using Random = UnityEngine.Random;
namespace Unity.Netcode.TestHelpers.Runtime namespace Unity.Netcode.TestHelpers.Runtime
{ {
public abstract class IntegrationTestWithApproximation : NetcodeIntegrationTest public abstract class IntegrationTestWithApproximation : NetcodeIntegrationTest
{ {
private const float k_AproximateDeltaVariance = 0.01f; private const float k_AproximateDeltaVariance = 0.016f;
protected string GetVector3Values(ref Vector3 vector3)
{
return $"({vector3.x:F6},{vector3.y:F6},{vector3.z:F6})";
}
protected string GetVector3Values(Vector3 vector3)
{
return GetVector3Values(ref vector3);
}
protected virtual float GetDeltaVarianceThreshold() protected virtual float GetDeltaVarianceThreshold()
{ {
@@ -40,17 +52,17 @@ namespace Unity.Netcode.TestHelpers.Runtime
protected bool Approximately(Vector2 a, Vector2 b) protected bool Approximately(Vector2 a, Vector2 b)
{ {
var deltaVariance = GetDeltaVarianceThreshold(); var deltaVariance = GetDeltaVarianceThreshold();
return Mathf.Abs(a.x - b.x) <= deltaVariance && return Math.Round(Mathf.Abs(a.x - b.x), 2) <= deltaVariance &&
Mathf.Abs(a.y - b.y) <= deltaVariance; Math.Round(Mathf.Abs(a.y - b.y), 2) <= deltaVariance;
} }
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
protected bool Approximately(Vector3 a, Vector3 b) protected bool Approximately(Vector3 a, Vector3 b)
{ {
var deltaVariance = GetDeltaVarianceThreshold(); var deltaVariance = GetDeltaVarianceThreshold();
return Mathf.Abs(a.x - b.x) <= deltaVariance && return Math.Round(Mathf.Abs(a.x - b.x), 2) <= deltaVariance &&
Mathf.Abs(a.y - b.y) <= deltaVariance && Math.Round(Mathf.Abs(a.y - b.y), 2) <= deltaVariance &&
Mathf.Abs(a.z - b.z) <= deltaVariance; Math.Round(Mathf.Abs(a.z - b.z), 2) <= deltaVariance;
} }
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -75,5 +87,10 @@ namespace Unity.Netcode.TestHelpers.Runtime
return new Vector3(Random.Range(min, max), Random.Range(min, max), Random.Range(min, max)); return new Vector3(Random.Range(min, max), Random.Range(min, max), Random.Range(min, max));
} }
public IntegrationTestWithApproximation(SessionModeTypes sessionModeType) : base(sessionModeType) { }
public IntegrationTestWithApproximation(HostOrServer hostOrServer) : base(hostOrServer) { }
public IntegrationTestWithApproximation() : base() { }
} }
} }

3
TestHelpers/Runtime/MockTimeProvider.cs
View File

@@ -7,6 +7,9 @@ namespace Unity.Netcode.TestHelpers.Runtime
public float UnscaledDeltaTime => (float)s_DoubleDelta; public float UnscaledDeltaTime => (float)s_DoubleDelta;
public float DeltaTime => (float)s_DoubleDelta; public float DeltaTime => (float)s_DoubleDelta;
// DANGO-EXP TODO: Figure out how we want to handle time travel with fixed delta time.
public float FixedDeltaTime => (float)s_DoubleDelta;
public static float StaticRealTimeSinceStartup => (float)s_DoubleRealTime; public static float StaticRealTimeSinceStartup => (float)s_DoubleRealTime;
public static float StaticUnscaledTime => (float)s_DoubleRealTime; public static float StaticUnscaledTime => (float)s_DoubleRealTime;
public static float StaticUnscaledDeltaTime => (float)s_DoubleDelta; public static float StaticUnscaledDeltaTime => (float)s_DoubleDelta;

326
TestHelpers/Runtime/NetcodeIntegrationTest.cs
View File

@@ -4,6 +4,7 @@ using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Reflection; using System.Reflection;
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
using System.Text;
using NUnit.Framework; using NUnit.Framework;
using Unity.Netcode.RuntimeTests; using Unity.Netcode.RuntimeTests;
using Unity.Netcode.Transports.UTP; using Unity.Netcode.Transports.UTP;
@@ -29,6 +30,13 @@ namespace Unity.Netcode.TestHelpers.Runtime
protected static WaitForSecondsRealtime s_DefaultWaitForTick = new WaitForSecondsRealtime(1.0f / k_DefaultTickRate); protected static WaitForSecondsRealtime s_DefaultWaitForTick = new WaitForSecondsRealtime(1.0f / k_DefaultTickRate);
public NetcodeLogAssert NetcodeLogAssert; public NetcodeLogAssert NetcodeLogAssert;
public enum SceneManagementState
{
SceneManagementEnabled,
SceneManagementDisabled
}
private StringBuilder m_InternalErrorLog = new StringBuilder();
/// <summary> /// <summary>
/// Registered list of all NetworkObjects spawned. /// Registered list of all NetworkObjects spawned.
@@ -112,7 +120,8 @@ namespace Unity.Netcode.TestHelpers.Runtime
public enum HostOrServer public enum HostOrServer
{ {
Host, Host,
Server Server,
DAHost
} }
protected GameObject m_PlayerPrefab; protected GameObject m_PlayerPrefab;
@@ -129,6 +138,26 @@ namespace Unity.Netcode.TestHelpers.Runtime
protected Dictionary<ulong, Dictionary<ulong, NetworkObject>> m_PlayerNetworkObjects = new Dictionary<ulong, Dictionary<ulong, NetworkObject>>(); protected Dictionary<ulong, Dictionary<ulong, NetworkObject>> m_PlayerNetworkObjects = new Dictionary<ulong, Dictionary<ulong, NetworkObject>>();
protected bool m_UseHost = true; protected bool m_UseHost = true;
protected bool m_DistributedAuthority;
protected SessionModeTypes m_SessionModeType = SessionModeTypes.ClientServer;
protected virtual bool UseCMBService()
{
return false;
}
protected virtual SessionModeTypes OnGetSessionmode()
{
return m_SessionModeType;
}
protected void SetDistributedAuthorityProperties(NetworkManager networkManager)
{
networkManager.NetworkConfig.SessionMode = m_SessionModeType;
networkManager.NetworkConfig.AutoSpawnPlayerPrefabClientSide = m_DistributedAuthority;
networkManager.NetworkConfig.UseCMBService = UseCMBService() && m_DistributedAuthority;
}
protected int m_TargetFrameRate = 60; protected int m_TargetFrameRate = 60;
private NetworkManagerInstatiationMode m_NetworkManagerInstatiationMode; private NetworkManagerInstatiationMode m_NetworkManagerInstatiationMode;
@@ -338,6 +367,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
else else
{ {
yield return StartServerAndClients(); yield return StartServerAndClients();
} }
} }
@@ -367,6 +397,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
m_PlayerPrefab = new GameObject("Player"); m_PlayerPrefab = new GameObject("Player");
OnPlayerPrefabGameObjectCreated(); OnPlayerPrefabGameObjectCreated();
NetworkObject networkObject = m_PlayerPrefab.AddComponent<NetworkObject>(); NetworkObject networkObject = m_PlayerPrefab.AddComponent<NetworkObject>();
networkObject.IsSceneObject = false;
// Make it a prefab // Make it a prefab
NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(networkObject); NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(networkObject);
@@ -455,6 +486,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
{ {
var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_EnableTimeTravel); var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_EnableTimeTravel);
networkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab; networkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab;
SetDistributedAuthorityProperties(networkManager);
// Notification that the new client (NetworkManager) has been created // Notification that the new client (NetworkManager) has been created
// in the event any modifications need to be made before starting the client // in the event any modifications need to be made before starting the client
@@ -483,12 +515,64 @@ namespace Unity.Netcode.TestHelpers.Runtime
Object.DestroyImmediate(networkManager.gameObject); Object.DestroyImmediate(networkManager.gameObject);
} }
AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for the new client to be connected!"); AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for the new client to be connected!\n {m_InternalErrorLog}");
ClientNetworkManagerPostStart(networkManager); ClientNetworkManagerPostStart(networkManager);
if (networkManager.DistributedAuthorityMode)
{
yield return WaitForConditionOrTimeOut(() => AllPlayerObjectClonesSpawned(networkManager));
AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for all sessions to spawn Client-{networkManager.LocalClientId}'s player object!");
}
VerboseDebug($"[{networkManager.name}] Created and connected!"); VerboseDebug($"[{networkManager.name}] Created and connected!");
} }
} }
private bool AllPlayerObjectClonesSpawned(NetworkManager joinedClient)
{
m_InternalErrorLog.Clear();
// Continue to populate the PlayerObjects list until all player object (local and clone) are found
ClientNetworkManagerPostStart(joinedClient);
var playerObjectRelative = m_ServerNetworkManager.SpawnManager.PlayerObjects.Where((c) => c.OwnerClientId == joinedClient.LocalClientId).FirstOrDefault();
if (playerObjectRelative == null)
{
m_InternalErrorLog.Append($"[AllPlayerObjectClonesSpawned][Server-Side] Joining Client-{joinedClient.LocalClientId} was not populated in the {nameof(NetworkSpawnManager.PlayerObjects)} list!");
return false;
}
else
{
// Go ahead and create an entry for this new client
if (!m_PlayerNetworkObjects[m_ServerNetworkManager.LocalClientId].ContainsKey(joinedClient.LocalClientId))
{
m_PlayerNetworkObjects[m_ServerNetworkManager.LocalClientId].Add(joinedClient.LocalClientId, playerObjectRelative);
}
}
foreach (var clientNetworkManager in m_ClientNetworkManagers)
{
if (clientNetworkManager.LocalClientId == joinedClient.LocalClientId)
{
continue;
}
playerObjectRelative = clientNetworkManager.SpawnManager.PlayerObjects.Where((c) => c.OwnerClientId == joinedClient.LocalClientId).FirstOrDefault();
if (playerObjectRelative == null)
{
m_InternalErrorLog.Append($"[AllPlayerObjectClonesSpawned][Client-{clientNetworkManager.LocalClientId}] Client-{joinedClient.LocalClientId} was not populated in the {nameof(NetworkSpawnManager.PlayerObjects)} list!");
return false;
}
else
{
// Go ahead and create an entry for this new client
if (!m_PlayerNetworkObjects[clientNetworkManager.LocalClientId].ContainsKey(joinedClient.LocalClientId))
{
m_PlayerNetworkObjects[clientNetworkManager.LocalClientId].Add(joinedClient.LocalClientId, playerObjectRelative);
}
}
}
return true;
}
/// <summary> /// <summary>
/// This will create, start, and connect a new client while in the middle of an /// This will create, start, and connect a new client while in the middle of an
/// integration test. /// integration test.
@@ -497,6 +581,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
{ {
var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_EnableTimeTravel); var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_EnableTimeTravel);
networkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab; networkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab;
SetDistributedAuthorityProperties(networkManager);
// Notification that the new client (NetworkManager) has been created // Notification that the new client (NetworkManager) has been created
// in the event any modifications need to be made before starting the client // in the event any modifications need to be made before starting the client
@@ -534,7 +619,10 @@ namespace Unity.Netcode.TestHelpers.Runtime
protected IEnumerator StopOneClient(NetworkManager networkManager, bool destroy = false) protected IEnumerator StopOneClient(NetworkManager networkManager, bool destroy = false)
{ {
NetcodeIntegrationTestHelpers.StopOneClient(networkManager, destroy); NetcodeIntegrationTestHelpers.StopOneClient(networkManager, destroy);
AddRemoveNetworkManager(networkManager, false); if (destroy)
{
AddRemoveNetworkManager(networkManager, false);
}
yield return WaitForConditionOrTimeOut(() => !networkManager.IsConnectedClient); yield return WaitForConditionOrTimeOut(() => !networkManager.IsConnectedClient);
} }
@@ -581,9 +669,12 @@ namespace Unity.Netcode.TestHelpers.Runtime
// Set the player prefab for the server and clients // Set the player prefab for the server and clients
m_ServerNetworkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab; m_ServerNetworkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab;
SetDistributedAuthorityProperties(m_ServerNetworkManager);
foreach (var client in m_ClientNetworkManagers) foreach (var client in m_ClientNetworkManagers)
{ {
client.NetworkConfig.PlayerPrefab = m_PlayerPrefab; client.NetworkConfig.PlayerPrefab = m_PlayerPrefab;
SetDistributedAuthorityProperties(client);
} }
// Provides opportunity to allow child derived classes to // Provides opportunity to allow child derived classes to
@@ -730,22 +821,27 @@ namespace Unity.Netcode.TestHelpers.Runtime
// Start the instances and pass in our SceneManagerInitialization action that is invoked immediately after host-server // Start the instances and pass in our SceneManagerInitialization action that is invoked immediately after host-server
// is started and after each client is started. // is started and after each client is started.
if (!NetcodeIntegrationTestHelpers.Start(m_UseHost, m_ServerNetworkManager, m_ClientNetworkManagers))
// When using the CMBService, don't start the server.
bool startServer = !(UseCMBService() && m_DistributedAuthority);
if (!NetcodeIntegrationTestHelpers.Start(m_UseHost, startServer, m_ServerNetworkManager, m_ClientNetworkManagers))
{ {
Debug.LogError("Failed to start instances"); Debug.LogError("Failed to start instances");
Assert.Fail("Failed to start instances"); 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 // 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 // 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. // to load their own scenes.
if (m_ServerNetworkManager.NetworkConfig.EnableSceneManagement) if (m_ServerNetworkManager.NetworkConfig.EnableSceneManagement)
{ {
var scenesLoaded = m_ServerNetworkManager.SceneManager.ScenesLoaded; if (startServer)
m_ServerNetworkManager.SceneManager.SceneManagerHandler.PopulateLoadedScenes(ref scenesLoaded, m_ServerNetworkManager); {
var scenesLoaded = m_ServerNetworkManager.SceneManager.ScenesLoaded;
m_ServerNetworkManager.SceneManager.SceneManagerHandler.PopulateLoadedScenes(ref scenesLoaded, m_ServerNetworkManager);
}
} }
if (LogAllMessages) if (LogAllMessages)
{ {
EnableMessageLogging(); EnableMessageLogging();
@@ -762,7 +858,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
// Wait for all clients to connect // Wait for all clients to connect
yield return WaitForClientsConnectedOrTimeOut(); yield return WaitForClientsConnectedOrTimeOut();
AssertOnTimeout($"{nameof(StartServerAndClients)} timed out waiting for all clients to be connected!"); AssertOnTimeout($"{nameof(StartServerAndClients)} timed out waiting for all clients to be connected!\n {m_InternalErrorLog}");
if (m_UseHost || m_ServerNetworkManager.IsHost) if (m_UseHost || m_ServerNetworkManager.IsHost)
{ {
@@ -783,9 +879,25 @@ namespace Unity.Netcode.TestHelpers.Runtime
m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(m_ServerNetworkManager.LocalClientId, playerNetworkObject); m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(m_ServerNetworkManager.LocalClientId, playerNetworkObject);
} }
} }
if (m_DistributedAuthority)
{
//yield return WaitForConditionOrTimeOut(AllClientPlayersSpawned);
//AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for all sessions to spawn all player objects!");
foreach (var networkManager in m_ClientNetworkManagers)
{
if (networkManager.DistributedAuthorityMode)
{
yield return WaitForConditionOrTimeOut(() => AllPlayerObjectClonesSpawned(networkManager));
AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for all sessions to spawn Client-{networkManager.LocalClientId}'s player object!\n {m_InternalErrorLog}");
}
}
if (m_ServerNetworkManager != null)
{
yield return WaitForConditionOrTimeOut(() => AllPlayerObjectClonesSpawned(m_ServerNetworkManager));
AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for all sessions to spawn Client-{m_ServerNetworkManager.LocalClientId}'s player object!\n {m_InternalErrorLog}");
}
}
ClientNetworkManagerPostStartInit(); ClientNetworkManagerPostStartInit();
// Notification that at this time the server and client(s) are instantiated, // Notification that at this time the server and client(s) are instantiated,
// started, and connected on both sides. // started, and connected on both sides.
yield return OnServerAndClientsConnected(); yield return OnServerAndClientsConnected();
@@ -807,7 +919,9 @@ namespace Unity.Netcode.TestHelpers.Runtime
// Start the instances and pass in our SceneManagerInitialization action that is invoked immediately after host-server // Start the instances and pass in our SceneManagerInitialization action that is invoked immediately after host-server
// is started and after each client is started. // is started and after each client is started.
if (!NetcodeIntegrationTestHelpers.Start(m_UseHost, m_ServerNetworkManager, m_ClientNetworkManagers)) // When using the CMBService, don't start the server.
var usingCMBService = UseCMBService() && m_DistributedAuthority;
if (!NetcodeIntegrationTestHelpers.Start(m_UseHost, !usingCMBService, m_ServerNetworkManager, m_ClientNetworkManagers))
{ {
Debug.LogError("Failed to start instances"); Debug.LogError("Failed to start instances");
Assert.Fail("Failed to start instances"); Assert.Fail("Failed to start instances");
@@ -857,6 +971,24 @@ namespace Unity.Netcode.TestHelpers.Runtime
} }
} }
if (m_DistributedAuthority)
{
foreach (var networkManager in m_ClientNetworkManagers)
{
if (networkManager.DistributedAuthorityMode)
{
WaitForConditionOrTimeOutWithTimeTravel(() => AllPlayerObjectClonesSpawned(m_ServerNetworkManager));
AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for all sessions to spawn Client-{networkManager.LocalClientId}'s player object!");
}
}
if (m_ServerNetworkManager != null)
{
WaitForConditionOrTimeOutWithTimeTravel(() => AllPlayerObjectClonesSpawned(m_ServerNetworkManager));
AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for all sessions to spawn Client-{m_ServerNetworkManager.LocalClientId}'s player object!");
}
}
ClientNetworkManagerPostStartInit(); ClientNetworkManagerPostStartInit();
// Notification that at this time the server and client(s) are instantiated, // Notification that at this time the server and client(s) are instantiated,
@@ -965,6 +1097,45 @@ namespace Unity.Netcode.TestHelpers.Runtime
VerboseDebug($"Exiting {nameof(ShutdownAndCleanUp)}"); VerboseDebug($"Exiting {nameof(ShutdownAndCleanUp)}");
} }
protected IEnumerator CoroutineShutdownAndCleanUp()
{
VerboseDebug($"Entering {nameof(ShutdownAndCleanUp)}");
// Shutdown and clean up both of our NetworkManager instances
try
{
DeRegisterSceneManagerHandler();
NetcodeIntegrationTestHelpers.Destroy();
m_PlayerNetworkObjects.Clear();
s_GlobalNetworkObjects.Clear();
}
catch (Exception e)
{
throw e;
}
finally
{
if (m_PlayerPrefab != null)
{
Object.DestroyImmediate(m_PlayerPrefab);
m_PlayerPrefab = null;
}
}
// Allow time for NetworkManagers to fully shutdown
yield return s_DefaultWaitForTick;
// Cleanup any remaining NetworkObjects
DestroySceneNetworkObjects();
UnloadRemainingScenes();
// reset the m_ServerWaitForTick for the next test to initialize
s_DefaultWaitForTick = new WaitForSecondsRealtime(1.0f / k_DefaultTickRate);
VerboseDebug($"Exiting {nameof(ShutdownAndCleanUp)}");
}
/// <summary> /// <summary>
/// Note: For <see cref="NetworkManagerInstatiationMode.PerTest"/> mode /// Note: For <see cref="NetworkManagerInstatiationMode.PerTest"/> mode
/// this is called before ShutdownAndCleanUp. /// this is called before ShutdownAndCleanUp.
@@ -994,7 +1165,14 @@ namespace Unity.Netcode.TestHelpers.Runtime
if (m_NetworkManagerInstatiationMode == NetworkManagerInstatiationMode.PerTest) if (m_NetworkManagerInstatiationMode == NetworkManagerInstatiationMode.PerTest)
{ {
ShutdownAndCleanUp(); if (m_TearDownIsACoroutine)
{
yield return CoroutineShutdownAndCleanUp();
}
else
{
ShutdownAndCleanUp();
}
} }
if (m_EnableTimeTravel) if (m_EnableTimeTravel)
@@ -1230,11 +1408,35 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// <param name="clientsToCheck">An array of clients to be checked</param> /// <param name="clientsToCheck">An array of clients to be checked</param>
protected IEnumerator WaitForClientsConnectedOrTimeOut(NetworkManager[] clientsToCheck) protected IEnumerator WaitForClientsConnectedOrTimeOut(NetworkManager[] clientsToCheck)
{ {
var remoteClientCount = clientsToCheck.Length; yield return WaitForConditionOrTimeOut(() => CheckClientsConnected(clientsToCheck));
var serverClientCount = m_ServerNetworkManager.IsHost ? remoteClientCount + 1 : remoteClientCount; }
yield return WaitForConditionOrTimeOut(() => clientsToCheck.Where((c) => c.IsConnectedClient).Count() == remoteClientCount && /// <summary>
m_ServerNetworkManager.ConnectedClients.Count == serverClientCount); /// Validation for clients connected that includes additional information for easier troubleshooting purposes.
/// </summary>
private bool CheckClientsConnected(NetworkManager[] clientsToCheck)
{
m_InternalErrorLog.Clear();
var allClientsConnected = true;
for (int i = 0; i < clientsToCheck.Length; i++)
{
if (!clientsToCheck[i].IsConnectedClient)
{
allClientsConnected = false;
m_InternalErrorLog.AppendLine($"[Client-{i + 1}] Client is not connected!");
}
}
var expectedCount = m_ServerNetworkManager.IsHost ? clientsToCheck.Length + 1 : clientsToCheck.Length;
var currentCount = m_ServerNetworkManager.ConnectedClients.Count;
if (currentCount != expectedCount)
{
allClientsConnected = false;
m_InternalErrorLog.AppendLine($"[Server-Side] Expected {expectedCount} clients to connect but only {currentCount} connected!");
}
return allClientsConnected;
} }
/// <summary> /// <summary>
@@ -1286,7 +1488,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
// Used to determine if all clients received the CreateObjectMessage // Used to determine if all clients received the CreateObjectMessage
var hooks = new MessageHooksConditional(messageHookEntriesForSpawn); var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
yield return WaitForConditionOrTimeOut(hooks); yield return WaitForConditionOrTimeOut(hooks);
Assert.False(s_GlobalTimeoutHelper.TimedOut); AssertOnTimeout($"Timed out waiting for message type {typeof(T).Name}!");
} }
internal IEnumerator WaitForMessagesReceived(List<Type> messagesInOrder, List<NetworkManager> waitForReceivedBy, ReceiptType type = ReceiptType.Handled) internal IEnumerator WaitForMessagesReceived(List<Type> messagesInOrder, List<NetworkManager> waitForReceivedBy, ReceiptType type = ReceiptType.Handled)
@@ -1306,7 +1508,12 @@ namespace Unity.Netcode.TestHelpers.Runtime
// Used to determine if all clients received the CreateObjectMessage // Used to determine if all clients received the CreateObjectMessage
var hooks = new MessageHooksConditional(messageHookEntriesForSpawn); var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
yield return WaitForConditionOrTimeOut(hooks); yield return WaitForConditionOrTimeOut(hooks);
Assert.False(s_GlobalTimeoutHelper.TimedOut); var stringBuilder = new StringBuilder();
foreach (var messageType in messagesInOrder)
{
stringBuilder.Append($"{messageType.Name},");
}
AssertOnTimeout($"Timed out waiting for message types: {stringBuilder}!");
} }
@@ -1323,7 +1530,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
// Used to determine if all clients received the CreateObjectMessage // Used to determine if all clients received the CreateObjectMessage
var hooks = new MessageHooksConditional(messageHookEntriesForSpawn); var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
Assert.True(WaitForConditionOrTimeOutWithTimeTravel(hooks)); Assert.True(WaitForConditionOrTimeOutWithTimeTravel(hooks), $"[Message Not Recieved] {hooks.GetHooksStillWaiting()}");
} }
internal void WaitForMessagesReceivedWithTimeTravel(List<Type> messagesInOrder, List<NetworkManager> waitForReceivedBy, ReceiptType type = ReceiptType.Handled) internal void WaitForMessagesReceivedWithTimeTravel(List<Type> messagesInOrder, List<NetworkManager> waitForReceivedBy, ReceiptType type = ReceiptType.Handled)
@@ -1342,7 +1549,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
// Used to determine if all clients received the CreateObjectMessage // Used to determine if all clients received the CreateObjectMessage
var hooks = new MessageHooksConditional(messageHookEntriesForSpawn); var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
Assert.True(WaitForConditionOrTimeOutWithTimeTravel(hooks)); Assert.True(WaitForConditionOrTimeOutWithTimeTravel(hooks), $"[Messages Not Recieved] {hooks.GetHooksStillWaiting()}");
} }
/// <summary> /// <summary>
@@ -1358,8 +1565,11 @@ namespace Unity.Netcode.TestHelpers.Runtime
$"but before {nameof(OnStartedServerAndClients)}!"; $"but before {nameof(OnStartedServerAndClients)}!";
Assert.IsNotNull(m_ServerNetworkManager, prefabCreateAssertError); Assert.IsNotNull(m_ServerNetworkManager, prefabCreateAssertError);
Assert.IsFalse(m_ServerNetworkManager.IsListening, prefabCreateAssertError); Assert.IsFalse(m_ServerNetworkManager.IsListening, prefabCreateAssertError);
var prefabObject = NetcodeIntegrationTestHelpers.CreateNetworkObjectPrefab(baseName, m_ServerNetworkManager, m_ClientNetworkManagers);
return NetcodeIntegrationTestHelpers.CreateNetworkObjectPrefab(baseName, m_ServerNetworkManager, m_ClientNetworkManagers); // DANGO-TODO: Ownership flags could require us to change this
// For testing purposes, we default to true for the distribute ownership property when in distirbuted authority session mode.
prefabObject.GetComponent<NetworkObject>().Ownership |= NetworkObject.OwnershipStatus.Distributable;
return prefabObject;
} }
/// <summary> /// <summary>
@@ -1372,6 +1582,16 @@ namespace Unity.Netcode.TestHelpers.Runtime
return SpawnObject(prefabNetworkObject, owner, destroyWithScene); return SpawnObject(prefabNetworkObject, owner, destroyWithScene);
} }
/// <summary>
/// Overloaded method <see cref="SpawnObject(NetworkObject, NetworkManager, bool)"/>
/// </summary>
protected GameObject SpawnPlayerObject(GameObject prefabGameObject, NetworkManager owner, bool destroyWithScene = false)
{
var prefabNetworkObject = prefabGameObject.GetComponent<NetworkObject>();
Assert.IsNotNull(prefabNetworkObject, $"{nameof(GameObject)} {prefabGameObject.name} does not have a {nameof(NetworkObject)} component!");
return SpawnObject(prefabNetworkObject, owner, destroyWithScene, true);
}
/// <summary> /// <summary>
/// Spawn a NetworkObject prefab instance /// Spawn a NetworkObject prefab instance
/// </summary> /// </summary>
@@ -1379,28 +1599,57 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// <param name="owner">the owner of the instance</param> /// <param name="owner">the owner of the instance</param>
/// <param name="destroyWithScene">default is false</param> /// <param name="destroyWithScene">default is false</param>
/// <returns>GameObject instance spawned</returns> /// <returns>GameObject instance spawned</returns>
private GameObject SpawnObject(NetworkObject prefabNetworkObject, NetworkManager owner, bool destroyWithScene = false) private GameObject SpawnObject(NetworkObject prefabNetworkObject, NetworkManager owner, bool destroyWithScene = false, bool isPlayerObject = false)
{ {
Assert.IsTrue(prefabNetworkObject.GlobalObjectIdHash > 0, $"{nameof(GameObject)} {prefabNetworkObject.name} has a {nameof(NetworkObject.GlobalObjectIdHash)} value of 0! Make sure to make it a valid prefab before trying to spawn!"); Assert.IsTrue(prefabNetworkObject.GlobalObjectIdHash > 0, $"{nameof(GameObject)} {prefabNetworkObject.name} has a {nameof(NetworkObject.GlobalObjectIdHash)} value of 0! Make sure to make it a valid prefab before trying to spawn!");
var newInstance = Object.Instantiate(prefabNetworkObject.gameObject); var newInstance = Object.Instantiate(prefabNetworkObject.gameObject);
var networkObjectToSpawn = newInstance.GetComponent<NetworkObject>(); var networkObjectToSpawn = newInstance.GetComponent<NetworkObject>();
networkObjectToSpawn.NetworkManagerOwner = m_ServerNetworkManager; // Required to assure the server does the spawning
if (owner == m_ServerNetworkManager) if (owner.NetworkConfig.SessionMode == SessionModeTypes.DistributedAuthority)
{ {
if (m_UseHost) networkObjectToSpawn.NetworkManagerOwner = owner; // Required to assure the client does the spawning
if (isPlayerObject)
{ {
networkObjectToSpawn.SpawnWithOwnership(owner.LocalClientId, destroyWithScene); networkObjectToSpawn.SpawnAsPlayerObject(owner.LocalClientId, destroyWithScene);
} }
else else
{ {
networkObjectToSpawn.Spawn(destroyWithScene); networkObjectToSpawn.SpawnWithOwnership(owner.LocalClientId, destroyWithScene);
} }
} }
else else
{ {
networkObjectToSpawn.SpawnWithOwnership(owner.LocalClientId, destroyWithScene); networkObjectToSpawn.NetworkManagerOwner = m_ServerNetworkManager; // Required to assure the server does the spawning
if (owner == m_ServerNetworkManager)
{
if (m_UseHost)
{
if (isPlayerObject)
{
networkObjectToSpawn.SpawnAsPlayerObject(owner.LocalClientId, destroyWithScene);
}
else
{
networkObjectToSpawn.SpawnWithOwnership(owner.LocalClientId, destroyWithScene);
}
}
else
{
networkObjectToSpawn.Spawn(destroyWithScene);
}
}
else
{
if (isPlayerObject)
{
networkObjectToSpawn.SpawnAsPlayerObject(owner.LocalClientId, destroyWithScene);
}
else
{
networkObjectToSpawn.SpawnWithOwnership(owner.LocalClientId, destroyWithScene);
}
}
} }
return newInstance; return newInstance;
} }
@@ -1438,6 +1687,15 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// </summary> /// </summary>
public NetcodeIntegrationTest() public NetcodeIntegrationTest()
{ {
m_SessionModeType = OnGetSessionmode();
m_DistributedAuthority = OnGetSessionmode() == SessionModeTypes.DistributedAuthority;
NetworkMessageManager.EnableMessageOrderConsoleLog = false;
}
public NetcodeIntegrationTest(SessionModeTypes sessionMode)
{
m_SessionModeType = sessionMode;
m_DistributedAuthority = OnGetSessionmode() == SessionModeTypes.DistributedAuthority;
} }
/// <summary> /// <summary>
@@ -1458,7 +1716,9 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// <param name="hostOrServer"></param> /// <param name="hostOrServer"></param>
public NetcodeIntegrationTest(HostOrServer hostOrServer) public NetcodeIntegrationTest(HostOrServer hostOrServer)
{ {
m_UseHost = hostOrServer == HostOrServer.Host ? true : false; m_UseHost = hostOrServer == HostOrServer.Host || hostOrServer == HostOrServer.DAHost;
m_SessionModeType = hostOrServer == HostOrServer.DAHost ? SessionModeTypes.DistributedAuthority : SessionModeTypes.ClientServer;
m_DistributedAuthority = OnGetSessionmode() == SessionModeTypes.DistributedAuthority;
} }
/// <summary> /// <summary>
@@ -1489,7 +1749,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
} }
} }
private System.Text.StringBuilder m_WaitForLog = new System.Text.StringBuilder(); private StringBuilder m_WaitForLog = new StringBuilder();
private void LogWaitForMessages() private void LogWaitForMessages()
{ {

55
TestHelpers/Runtime/NetcodeIntegrationTestHelpers.cs
View File

@@ -410,12 +410,31 @@ namespace Unity.Netcode.TestHelpers.Runtime
{ {
networkManager.SceneManager.ScenesLoaded.Add(scene.handle, scene); networkManager.SceneManager.ScenesLoaded.Add(scene.handle, scene);
} }
// In distributed authority we need to check if this scene is already added
if (networkManager.DistributedAuthorityMode)
{
if (!networkManager.SceneManager.ServerSceneHandleToClientSceneHandle.ContainsKey(scene.handle))
{
networkManager.SceneManager.ServerSceneHandleToClientSceneHandle.Add(scene.handle, scene.handle);
}
if (!networkManager.SceneManager.ClientSceneHandleToServerSceneHandle.ContainsKey(scene.handle))
{
networkManager.SceneManager.ClientSceneHandleToServerSceneHandle.Add(scene.handle, scene.handle);
}
return;
}
networkManager.SceneManager.ServerSceneHandleToClientSceneHandle.Add(scene.handle, scene.handle); networkManager.SceneManager.ServerSceneHandleToClientSceneHandle.Add(scene.handle, scene.handle);
} }
} }
public delegate void BeforeClientStartCallback(); public delegate void BeforeClientStartCallback();
internal static bool Start(bool host, bool startServer, NetworkManager server, NetworkManager[] clients)
{
return Start(host, server, clients, null, startServer);
}
/// <summary> /// <summary>
/// Starts NetworkManager instances created by the Create method. /// Starts NetworkManager instances created by the Create method.
/// </summary> /// </summary>
@@ -424,7 +443,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// <param name="clients">The Clients NetworkManager</param> /// <param name="clients">The Clients NetworkManager</param>
/// <param name="callback">called immediately after server is started and before client(s) are started</param> /// <param name="callback">called immediately after server is started and before client(s) are started</param>
/// <returns></returns> /// <returns></returns>
public static bool Start(bool host, NetworkManager server, NetworkManager[] clients, BeforeClientStartCallback callback = null) public static bool Start(bool host, NetworkManager server, NetworkManager[] clients, BeforeClientStartCallback callback = null, bool startServer = true)
{ {
if (s_IsStarted) if (s_IsStarted)
{ {
@@ -433,24 +452,26 @@ namespace Unity.Netcode.TestHelpers.Runtime
s_IsStarted = true; s_IsStarted = true;
s_ClientCount = clients.Length; s_ClientCount = clients.Length;
var hooks = (MultiInstanceHooks)null;
if (host) if (startServer)
{ {
server.StartHost(); if (host)
{
server.StartHost();
}
else
{
server.StartServer();
}
hooks = new MultiInstanceHooks();
server.ConnectionManager.MessageManager.Hook(hooks);
s_Hooks[server] = hooks;
// Register the server side handler (always pass true for server)
RegisterHandlers(server, true);
callback?.Invoke();
} }
else
{
server.StartServer();
}
var hooks = new MultiInstanceHooks();
server.ConnectionManager.MessageManager.Hook(hooks);
s_Hooks[server] = hooks;
// Register the server side handler (always pass true for server)
RegisterHandlers(server, true);
callback?.Invoke();
for (int i = 0; i < clients.Length; i++) for (int i = 0; i < clients.Length; i++)
{ {

2
Tests/Editor/Build/BuildTests.cs
View File

@@ -1,3 +1,4 @@
#if !MULTIPLAYER_TOOLS
using System.IO; using System.IO;
using System.Reflection; using System.Reflection;
using NUnit.Framework; using NUnit.Framework;
@@ -38,3 +39,4 @@ namespace Unity.Netcode.EditorTests
} }
} }
} }
#endif

5
Tests/Editor/Serialization/FastBufferWriterTests.cs
View File

@@ -311,8 +311,11 @@ namespace Unity.Netcode.EditorTests
{ {
int* sizeValue = (int*)(unsafePtr + offset); int* sizeValue = (int*)(unsafePtr + offset);
Assert.AreEqual(value.Length, *sizeValue); Assert.AreEqual(value.Length, *sizeValue);
#if UTP_TRANSPORT_2_0_ABOVE
var asTPointer = value.GetUnsafePtr();
#else
var asTPointer = (T*)value.GetUnsafePtr(); var asTPointer = (T*)value.GetUnsafePtr();
#endif
var underlyingTArray = (T*)(unsafePtr + sizeof(int) + offset); var underlyingTArray = (T*)(unsafePtr + sizeof(int) + offset);
for (var i = 0; i < value.Length; ++i) for (var i = 0; i < value.Length; ++i)
{ {

2
Tests/Editor/Transports/BatchedReceiveQueueTests.cs
View File

@@ -2,7 +2,9 @@ using System;
using NUnit.Framework; using NUnit.Framework;
using Unity.Collections; using Unity.Collections;
using Unity.Netcode.Transports.UTP; using Unity.Netcode.Transports.UTP;
#if !UTP_TRANSPORT_2_0_ABOVE
using Unity.Networking.Transport; using Unity.Networking.Transport;
#endif
namespace Unity.Netcode.EditorTests namespace Unity.Netcode.EditorTests
{ {

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

@@ -2,7 +2,9 @@ using System;
using NUnit.Framework; using NUnit.Framework;
using Unity.Collections; using Unity.Collections;
using Unity.Netcode.Transports.UTP; using Unity.Netcode.Transports.UTP;
#if !UTP_TRANSPORT_2_0_ABOVE
using Unity.Networking.Transport; using Unity.Networking.Transport;
#endif
namespace Unity.Netcode.EditorTests namespace Unity.Netcode.EditorTests
{ {

13
Tests/Runtime/ConnectionApprovalTimeoutTests.cs
View File

@@ -26,9 +26,9 @@ namespace Unity.Netcode.RuntimeTests
m_ApprovalFailureType = approvalFailureType; m_ApprovalFailureType = approvalFailureType;
} }
// Must be >= 2 since this is an int value and the test waits for timeout - 1 to try to verify it doesn't // Must be >= 5 since this is an int value and the test waits for timeout - 1 to try to verify it doesn't
// time out early // time out early
private const int k_TestTimeoutPeriod = 1; private const int k_TestTimeoutPeriod = 5;
private Regex m_ExpectedLogMessage; private Regex m_ExpectedLogMessage;
private LogType m_LogType; private LogType m_LogType;
@@ -59,6 +59,7 @@ namespace Unity.Netcode.RuntimeTests
{ {
if (m_ApprovalFailureType == ApprovalTimedOutTypes.ServerDoesNotRespond) if (m_ApprovalFailureType == ApprovalTimedOutTypes.ServerDoesNotRespond)
{ {
m_ServerNetworkManager.ConnectionManager.MockSkippingApproval = true;
// We catch (don't process) the incoming approval message to simulate the server not sending the approved message in time // We catch (don't process) the incoming approval message to simulate the server not sending the approved message in time
m_ClientNetworkManagers[0].ConnectionManager.MessageManager.Hook(new MessageCatcher<ConnectionApprovedMessage>(m_ClientNetworkManagers[0])); m_ClientNetworkManagers[0].ConnectionManager.MessageManager.Hook(new MessageCatcher<ConnectionApprovedMessage>(m_ClientNetworkManagers[0]));
m_ExpectedLogMessage = new Regex("Timed out waiting for the server to approve the connection request."); m_ExpectedLogMessage = new Regex("Timed out waiting for the server to approve the connection request.");
@@ -80,18 +81,18 @@ namespace Unity.Netcode.RuntimeTests
[UnityTest] [UnityTest]
public IEnumerator ValidateApprovalTimeout() public IEnumerator ValidateApprovalTimeout()
{ {
// Delay for half of the wait period // Just delay for a second
yield return new WaitForSeconds(k_TestTimeoutPeriod * 0.5f); yield return new WaitForSeconds(1);
// Verify we haven't received the time out message yet // Verify we haven't received the time out message yet
NetcodeLogAssert.LogWasNotReceived(LogType.Log, m_ExpectedLogMessage); NetcodeLogAssert.LogWasNotReceived(LogType.Log, m_ExpectedLogMessage);
yield return new WaitForSeconds(k_TestTimeoutPeriod * 1.5f); yield return new WaitForSeconds(k_TestTimeoutPeriod * 1.25f);
// We should have the test relative log message by this time. // We should have the test relative log message by this time.
NetcodeLogAssert.LogWasReceived(m_LogType, m_ExpectedLogMessage); NetcodeLogAssert.LogWasReceived(m_LogType, m_ExpectedLogMessage);
Debug.Log("Checking connected client count"); VerboseDebug("Checking connected client count");
// It should only have the host client connected // It should only have the host client connected
Assert.AreEqual(1, m_ServerNetworkManager.ConnectedClients.Count, $"Expected only one client when there were {m_ServerNetworkManager.ConnectedClients.Count} clients connected!"); Assert.AreEqual(1, m_ServerNetworkManager.ConnectedClients.Count, $"Expected only one client when there were {m_ServerNetworkManager.ConnectedClients.Count} clients connected!");

30
Tests/Runtime/DeferredMessagingTests.cs
View File

@@ -5,6 +5,7 @@ using NUnit.Framework;
using Unity.Netcode.TestHelpers.Runtime; using Unity.Netcode.TestHelpers.Runtime;
using UnityEngine; using UnityEngine;
using UnityEngine.TestTools; using UnityEngine.TestTools;
using Object = UnityEngine.Object; using Object = UnityEngine.Object;
namespace Unity.Netcode.RuntimeTests namespace Unity.Netcode.RuntimeTests
@@ -84,12 +85,11 @@ namespace Unity.Netcode.RuntimeTests
return 0; return 0;
} }
public override void DeferMessage(IDeferredNetworkMessageManager.TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context, string messageType)
public override void DeferMessage(IDeferredNetworkMessageManager.TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context)
{ {
OnBeforeDefer?.Invoke(this, key); OnBeforeDefer?.Invoke(this, key);
DeferMessageCalled = true; DeferMessageCalled = true;
base.DeferMessage(trigger, key, reader, ref context); base.DeferMessage(trigger, key, reader, ref context, messageType);
} }
public override void ProcessTriggers(IDeferredNetworkMessageManager.TriggerType trigger, ulong key) public override void ProcessTriggers(IDeferredNetworkMessageManager.TriggerType trigger, ulong key)
@@ -203,6 +203,9 @@ namespace Unity.Netcode.RuntimeTests
protected override void OnInlineSetup() protected override void OnInlineSetup()
{ {
// Revert back to standard deferred message format for tests (for now)
DeferredMessageManager.IncludeMessageType = false;
DeferredMessageTestRpcAndNetworkVariableComponent.ClientInstances.Clear(); DeferredMessageTestRpcAndNetworkVariableComponent.ClientInstances.Clear();
DeferredMessageTestRpcComponent.ClientInstances.Clear(); DeferredMessageTestRpcComponent.ClientInstances.Clear();
DeferredMessageTestNetworkVariableComponent.ClientInstances.Clear(); DeferredMessageTestNetworkVariableComponent.ClientInstances.Clear();
@@ -894,7 +897,7 @@ namespace Unity.Netcode.RuntimeTests
foreach (var unused in m_ClientNetworkManagers) foreach (var unused in m_ClientNetworkManagers)
{ {
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s)."); LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} associated with id ({serverObject.GetComponent<NetworkObject>().NetworkObjectId}), but the {nameof(NetworkObject)} was not received within the timeout period {timeout} second(s).");
} }
int purgeCount = 0; int purgeCount = 0;
@@ -904,7 +907,7 @@ namespace Unity.Netcode.RuntimeTests
{ {
++purgeCount; ++purgeCount;
var elapsed = client.RealTimeProvider.RealTimeSinceStartup - start; var elapsed = client.RealTimeProvider.RealTimeSinceStartup - start;
Debug.Log(client.RealTimeProvider.GetType().FullName); VerboseDebug(client.RealTimeProvider.GetType().FullName);
Assert.GreaterOrEqual(elapsed, timeout); Assert.GreaterOrEqual(elapsed, timeout);
Assert.AreEqual(1, manager.DeferredMessageCountTotal()); Assert.AreEqual(1, manager.DeferredMessageCountTotal());
Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn)); Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
@@ -990,7 +993,7 @@ namespace Unity.Netcode.RuntimeTests
foreach (var unused in m_ClientNetworkManagers) foreach (var unused in m_ClientNetworkManagers)
{ {
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s)."); LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} associated with id ({serverObject.GetComponent<NetworkObject>().NetworkObjectId}), but the {nameof(NetworkObject)} was not received within the timeout period {timeout} second(s).");
} }
int purgeCount = 0; int purgeCount = 0;
@@ -1095,9 +1098,8 @@ namespace Unity.Netcode.RuntimeTests
foreach (var unused in m_ClientNetworkManagers) foreach (var unused in m_ClientNetworkManagers)
{ {
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} associated with id ({serverObject.GetComponent<NetworkObject>().NetworkObjectId}), but the {nameof(NetworkObject)} was not received within the timeout period {timeout} second(s).");
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s)."); LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} associated with id ({serverObject2.GetComponent<NetworkObject>().NetworkObjectId}), but the {nameof(NetworkObject)} was not received within the timeout period {timeout} second(s).");
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} with key {serverObject2.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
} }
int purgeCount = 0; int purgeCount = 0;
@@ -1188,7 +1190,7 @@ namespace Unity.Netcode.RuntimeTests
foreach (var unused in m_ClientNetworkManagers) foreach (var unused in m_ClientNetworkManagers)
{ {
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s)."); LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} associated with id ({serverObject.GetComponent<NetworkObject>().NetworkObjectId}), but the {nameof(NetworkObject)} was not received within the timeout period {timeout} second(s).");
} }
int purgeCount = 0; int purgeCount = 0;
@@ -1271,7 +1273,11 @@ namespace Unity.Netcode.RuntimeTests
Assert.AreEqual(0, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject2.GetComponent<NetworkObject>().NetworkObjectId)); Assert.AreEqual(0, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject2.GetComponent<NetworkObject>().NetworkObjectId));
} }
serverObject2.GetComponent<NetworkObject>().ChangeOwnership(m_ServerNetworkManager.LocalClientId); // KITTY-TODO: Review this change please:
// Changing ownership when the owner specified is already an owner should not send any messages
// The original test was changing ownership to the server when the object was spawned with the server being an owner.
//serverObject2.GetComponent<NetworkObject>().ChangeOwnership(m_ServerNetworkManager.LocalClientId);
serverObject2.GetComponent<NetworkObject>().ChangeOwnership(m_ClientNetworkManagers[1].LocalClientId);
WaitForAllClientsToReceive<ChangeOwnershipMessage>(); WaitForAllClientsToReceive<ChangeOwnershipMessage>();
foreach (var client in m_ClientNetworkManagers) foreach (var client in m_ClientNetworkManagers)
@@ -1285,7 +1291,7 @@ namespace Unity.Netcode.RuntimeTests
foreach (var unused in m_ClientNetworkManagers) foreach (var unused in m_ClientNetworkManagers)
{ {
LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s)."); LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} associated with id ({serverObject.GetComponent<NetworkObject>().NetworkObjectId}), but the {nameof(NetworkObject)} was not received within the timeout period {timeout} second(s).");
} }
int purgeCount = 0; int purgeCount = 0;

51
Tests/Runtime/DisconnectTests.cs
View File

@@ -1,4 +1,5 @@
using System.Collections; using System.Collections;
using System.Collections.Generic;
using System.Linq; using System.Linq;
using NUnit.Framework; using NUnit.Framework;
using Unity.Netcode.TestHelpers.Runtime; using Unity.Netcode.TestHelpers.Runtime;
@@ -37,7 +38,10 @@ namespace Unity.Netcode.RuntimeTests
protected override int NumberOfClients => 1; protected override int NumberOfClients => 1;
private OwnerPersistence m_OwnerPersistence; private OwnerPersistence m_OwnerPersistence;
private ClientDisconnectType m_ClientDisconnectType;
private bool m_ClientDisconnected; private bool m_ClientDisconnected;
private Dictionary<NetworkManager, ConnectionEventData> m_DisconnectedEvent = new Dictionary<NetworkManager, ConnectionEventData>();
private ulong m_DisconnectEventClientId;
private ulong m_TransportClientId; private ulong m_TransportClientId;
private ulong m_ClientId; private ulong m_ClientId;
@@ -89,6 +93,16 @@ namespace Unity.Netcode.RuntimeTests
m_ClientDisconnected = true; m_ClientDisconnected = true;
} }
private void OnConnectionEvent(NetworkManager networkManager, ConnectionEventData connectionEventData)
{
if (connectionEventData.EventType != ConnectionEvent.ClientDisconnected)
{
return;
}
m_DisconnectedEvent.Add(networkManager, connectionEventData);
}
/// <summary> /// <summary>
/// Conditional check to assure the transport to client (and vice versa) mappings are cleaned up /// Conditional check to assure the transport to client (and vice versa) mappings are cleaned up
/// </summary> /// </summary>
@@ -126,6 +140,7 @@ namespace Unity.Netcode.RuntimeTests
public IEnumerator ClientPlayerDisconnected([Values] ClientDisconnectType clientDisconnectType) public IEnumerator ClientPlayerDisconnected([Values] ClientDisconnectType clientDisconnectType)
{ {
m_ClientId = m_ClientNetworkManagers[0].LocalClientId; m_ClientId = m_ClientNetworkManagers[0].LocalClientId;
m_ClientDisconnectType = clientDisconnectType;
var serverSideClientPlayer = m_ServerNetworkManager.ConnectionManager.ConnectedClients[m_ClientId].PlayerObject; var serverSideClientPlayer = m_ServerNetworkManager.ConnectionManager.ConnectedClients[m_ClientId].PlayerObject;
@@ -134,11 +149,15 @@ namespace Unity.Netcode.RuntimeTests
if (clientDisconnectType == ClientDisconnectType.ServerDisconnectsClient) if (clientDisconnectType == ClientDisconnectType.ServerDisconnectsClient)
{ {
m_ClientNetworkManagers[0].OnClientDisconnectCallback += OnClientDisconnectCallback; m_ClientNetworkManagers[0].OnClientDisconnectCallback += OnClientDisconnectCallback;
m_ClientNetworkManagers[0].OnConnectionEvent += OnConnectionEvent;
m_ServerNetworkManager.OnConnectionEvent += OnConnectionEvent;
m_ServerNetworkManager.DisconnectClient(m_ClientId); m_ServerNetworkManager.DisconnectClient(m_ClientId);
} }
else else
{ {
m_ServerNetworkManager.OnClientDisconnectCallback += OnClientDisconnectCallback; m_ServerNetworkManager.OnClientDisconnectCallback += OnClientDisconnectCallback;
m_ServerNetworkManager.OnConnectionEvent += OnConnectionEvent;
m_ClientNetworkManagers[0].OnConnectionEvent += OnConnectionEvent;
yield return StopOneClient(m_ClientNetworkManagers[0]); yield return StopOneClient(m_ClientNetworkManagers[0]);
} }
@@ -146,6 +165,23 @@ namespace Unity.Netcode.RuntimeTests
yield return WaitForConditionOrTimeOut(() => m_ClientDisconnected); yield return WaitForConditionOrTimeOut(() => m_ClientDisconnected);
AssertOnTimeout("Timed out waiting for client to disconnect!"); AssertOnTimeout("Timed out waiting for client to disconnect!");
if (clientDisconnectType == ClientDisconnectType.ServerDisconnectsClient)
{
Assert.IsTrue(m_DisconnectedEvent.ContainsKey(m_ServerNetworkManager), $"Could not find the server {nameof(NetworkManager)} disconnect event entry!");
Assert.IsTrue(m_DisconnectedEvent[m_ServerNetworkManager].ClientId == m_ClientId, $"Expected ClientID {m_ClientId} but found ClientID {m_DisconnectedEvent[m_ServerNetworkManager].ClientId} for the server {nameof(NetworkManager)} disconnect event entry!");
Assert.IsTrue(m_DisconnectedEvent.ContainsKey(m_ClientNetworkManagers[0]), $"Could not find the client {nameof(NetworkManager)} disconnect event entry!");
Assert.IsTrue(m_DisconnectedEvent[m_ClientNetworkManagers[0]].ClientId == m_ClientId, $"Expected ClientID {m_ClientId} but found ClientID {m_DisconnectedEvent[m_ServerNetworkManager].ClientId} for the client {nameof(NetworkManager)} disconnect event entry!");
// Unregister for this event otherwise it will be invoked during teardown
m_ServerNetworkManager.OnConnectionEvent -= OnConnectionEvent;
}
else
{
Assert.IsTrue(m_DisconnectedEvent.ContainsKey(m_ServerNetworkManager), $"Could not find the server {nameof(NetworkManager)} disconnect event entry!");
Assert.IsTrue(m_DisconnectedEvent[m_ServerNetworkManager].ClientId == m_ClientId, $"Expected ClientID {m_ClientId} but found ClientID {m_DisconnectedEvent[m_ServerNetworkManager].ClientId} for the server {nameof(NetworkManager)} disconnect event entry!");
Assert.IsTrue(m_DisconnectedEvent.ContainsKey(m_ClientNetworkManagers[0]), $"Could not find the client {nameof(NetworkManager)} disconnect event entry!");
Assert.IsTrue(m_DisconnectedEvent[m_ClientNetworkManagers[0]].ClientId == m_ClientId, $"Expected ClientID {m_ClientId} but found ClientID {m_DisconnectedEvent[m_ServerNetworkManager].ClientId} for the client {nameof(NetworkManager)} disconnect event entry!");
}
if (m_OwnerPersistence == OwnerPersistence.DestroyWithOwner) if (m_OwnerPersistence == OwnerPersistence.DestroyWithOwner)
{ {
// When we are destroying with the owner, validate the player object is destroyed on the server side // When we are destroying with the owner, validate the player object is destroyed on the server side
@@ -161,6 +197,21 @@ namespace Unity.Netcode.RuntimeTests
yield return WaitForConditionOrTimeOut(TransportIdCleanedUp); yield return WaitForConditionOrTimeOut(TransportIdCleanedUp);
AssertOnTimeout("Timed out waiting for transport and client id mappings to be cleaned up!"); AssertOnTimeout("Timed out waiting for transport and client id mappings to be cleaned up!");
// Validate the host-client generates a OnClientDisconnected event when it shutsdown.
// Only test when the test run is the client disconnecting from the server (otherwise the server will be shutdown already)
if (clientDisconnectType == ClientDisconnectType.ClientDisconnectsFromServer)
{
m_DisconnectedEvent.Clear();
m_ClientDisconnected = false;
m_ServerNetworkManager.Shutdown();
yield return WaitForConditionOrTimeOut(() => m_ClientDisconnected);
AssertOnTimeout("Timed out waiting for host-client to generate disconnect message!");
Assert.IsTrue(m_DisconnectedEvent.ContainsKey(m_ServerNetworkManager), $"Could not find the server {nameof(NetworkManager)} disconnect event entry!");
Assert.IsTrue(m_DisconnectedEvent[m_ServerNetworkManager].ClientId == NetworkManager.ServerClientId, $"Expected ClientID {m_ClientId} but found ClientID {m_DisconnectedEvent[m_ServerNetworkManager].ClientId} for the server {nameof(NetworkManager)} disconnect event entry!");
}
} }
} }
} }

8
Tests/Runtime/DistributedAuthority.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 421e3306c97e10f47b9efb6101a998ee
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

266
Tests/Runtime/DistributedAuthority/DeferredDespawningTests.cs Normal file
View File

@@ -0,0 +1,266 @@
using System;
using System.Collections;
using System.Collections.Generic;
using NUnit.Framework;
using Unity.Netcode.TestHelpers.Runtime;
using UnityEngine;
using UnityEngine.TestTools;
namespace Unity.Netcode.RuntimeTests
{
public class DeferredDespawningTests : IntegrationTestWithApproximation
{
private const int k_DaisyChainedCount = 5;
protected override int NumberOfClients => 2;
private List<GameObject> m_DaisyChainedDespawnObjects = new List<GameObject>();
private List<ulong> m_HasReachedEnd = new List<ulong>();
public DeferredDespawningTests() : base(HostOrServer.DAHost)
{
}
protected override void OnServerAndClientsCreated()
{
var daisyChainPrevious = (DeferredDespawnDaisyChained)null;
for (int i = 0; i < k_DaisyChainedCount; i++)
{
var daisyChainNode = CreateNetworkObjectPrefab($"Daisy-{i}");
var daisyChainBehaviour = daisyChainNode.AddComponent<DeferredDespawnDaisyChained>();
daisyChainBehaviour.IsRoot = i == 0;
if (daisyChainPrevious != null)
{
daisyChainPrevious.PrefabToSpawnWhenDespawned = daisyChainBehaviour.gameObject;
}
m_DaisyChainedDespawnObjects.Add(daisyChainNode);
daisyChainPrevious = daisyChainBehaviour;
}
base.OnServerAndClientsCreated();
}
[UnityTest]
public IEnumerator DeferredDespawning()
{
DeferredDespawnDaisyChained.EnableVerbose = m_EnableVerboseDebug;
var rootInstance = SpawnObject(m_DaisyChainedDespawnObjects[0], m_ServerNetworkManager);
DeferredDespawnDaisyChained.ReachedLastChainInstance = ReachedLastChainObject;
var timeoutHelper = new TimeoutHelper(300);
yield return WaitForConditionOrTimeOut(HaveAllClientsReachedEndOfChain, timeoutHelper);
AssertOnTimeout($"Timed out waiting for all children to reach the end of their chained deferred despawns!", timeoutHelper);
}
private bool HaveAllClientsReachedEndOfChain()
{
if (!m_HasReachedEnd.Contains(m_ServerNetworkManager.LocalClientId))
{
return false;
}
foreach (var client in m_ClientNetworkManagers)
{
if (!m_HasReachedEnd.Contains(client.LocalClientId))
{
return false;
}
}
return true;
}
private void ReachedLastChainObject(ulong clientId)
{
m_HasReachedEnd.Add(clientId);
}
}
/// <summary>
/// This helper behaviour handles the majority of the validation for deferred despawning.
/// Each instance triggers a series of deferred despawns where the owner validates the
/// NetworkVariables are updated and spawns another prefab prior to despawning locally
/// and the non-owners validate receiving the NetworkVariable change notification which
/// contains a reference to a DeferredDespawnDaisyChained component on the newly spawned
/// prefab driven by the authority. This repeats for the number specified in the integration
/// test.
/// </summary>
public class DeferredDespawnDaisyChained : NetworkBehaviour
{
public static bool EnableVerbose;
public static Action<ulong> ReachedLastChainInstance;
private const int k_StartingDeferTick = 4;
public static Dictionary<ulong, Dictionary<ulong, DeferredDespawnDaisyChained>> ClientRelativeInstances = new Dictionary<ulong, Dictionary<ulong, DeferredDespawnDaisyChained>>();
public bool IsRoot;
public GameObject PrefabToSpawnWhenDespawned;
public bool WasContactedByPeviousChainMember { get; private set; }
public int DeferDespawnTick { get; private set; }
private void PingInstance()
{
WasContactedByPeviousChainMember = true;
}
/// <summary>
/// This hits two birds with one NetworkVariable:
/// - Validates that NetworkVariables modified while the authority is in the middle of deferring a despawn are serialized and received by non-authority instances.
/// - Validates that the non-authority instances receive the updates within the deferred tick period of time and can use them to handle other visual synchronization
/// realted tasks (or the like).
/// </summary>
private NetworkVariable<NetworkBehaviourReference> m_ValidateDirtyNetworkVarUpdate = new NetworkVariable<NetworkBehaviourReference>();
private DeferredDespawnDaisyChained m_NextNodeSpawned = null;
private void FailTest(string msg)
{
Assert.Fail($"[{nameof(DeferredDespawnDaisyChained)}][Client-{NetworkManager.LocalClientId}] {msg}");
}
public override void OnNetworkSpawn()
{
var localId = NetworkManager.LocalClientId;
if (!ClientRelativeInstances.ContainsKey(localId))
{
ClientRelativeInstances.Add(localId, new Dictionary<ulong, DeferredDespawnDaisyChained>());
}
if (ClientRelativeInstances[localId].ContainsKey(NetworkObject.NetworkObjectId))
{
FailTest($"[{nameof(OnNetworkSpawn)}] Client already has a table entry for NetworkObject-{NetworkObject.NetworkObjectId} | {name}!");
}
ClientRelativeInstances[localId].Add(NetworkObject.NetworkObjectId, this);
if (!HasAuthority)
{
m_ValidateDirtyNetworkVarUpdate.OnValueChanged += OnValidateDirtyChanged;
}
if (HasAuthority && IsRoot)
{
DeferDespawnTick = k_StartingDeferTick;
}
base.OnNetworkSpawn();
}
private void OnValidateDirtyChanged(NetworkBehaviourReference previous, NetworkBehaviourReference current)
{
if (!HasAuthority)
{
if (!current.TryGet(out m_NextNodeSpawned, NetworkManager))
{
FailTest($"[{nameof(OnValidateDirtyChanged)}][{nameof(NetworkBehaviourReference)}] Failed to get the {nameof(DeferredDespawnDaisyChained)} behaviour from the {nameof(NetworkBehaviourReference)}!");
}
if (m_NextNodeSpawned.NetworkManager != NetworkManager)
{
FailTest($"[{nameof(NetworkManager)}][{nameof(NetworkBehaviourReference.TryGet)}] The {nameof(NetworkManager)} of {nameof(m_NextNodeSpawned)} does not match the local relative {nameof(NetworkManager)} instance!");
}
}
}
public override void OnNetworkDespawn()
{
if (!HasAuthority && !NetworkManager.ShutdownInProgress)
{
if (PrefabToSpawnWhenDespawned != null)
{
m_NextNodeSpawned.PingInstance();
}
else
{
ReachedLastChainInstance?.Invoke(NetworkManager.LocalClientId);
}
}
base.OnNetworkDespawn();
}
private void InvokeDespawn()
{
if (!HasAuthority)
{
FailTest($"[{nameof(InvokeDespawn)}] Client is not the authority but this was invoked (integration test logic issue)!");
}
NetworkObject.DeferDespawn(DeferDespawnTick);
}
public override void OnDeferringDespawn(int despawnTick)
{
if (!HasAuthority)
{
FailTest($"[{nameof(OnDeferringDespawn)}] Client is not the authority but this was invoked (integration test logic issue)!");
}
if (despawnTick != (DeferDespawnTick + NetworkManager.ServerTime.Tick))
{
FailTest($"[{nameof(OnDeferringDespawn)}] The passed in {despawnTick} parameter ({despawnTick}) does not equal the expected value of ({DeferDespawnTick + NetworkManager.ServerTime.Tick})!");
}
if (PrefabToSpawnWhenDespawned != null)
{
var deferNetworkObject = PrefabToSpawnWhenDespawned.GetComponent<NetworkObject>().InstantiateAndSpawn(NetworkManager);
var deferComponent = deferNetworkObject.GetComponent<DeferredDespawnDaisyChained>();
// Slowly increment the despawn tick count as we process the chain of deferred despawns
deferComponent.DeferDespawnTick = DeferDespawnTick + 1;
// This should get updated on all non-authority instances before they despawn
m_ValidateDirtyNetworkVarUpdate.Value = new NetworkBehaviourReference(deferComponent);
}
else
{
ReachedLastChainInstance?.Invoke(NetworkManager.LocalClientId);
}
base.OnDeferringDespawn(despawnTick);
}
private bool m_DeferredDespawn;
private void Update()
{
if (!IsSpawned || !HasAuthority || m_DeferredDespawn)
{
return;
}
// Wait until all clients have this instance
foreach (var clientId in NetworkManager.ConnectedClientsIds)
{
if (!ClientRelativeInstances.ContainsKey(clientId))
{
// exit early if the client doesn't exist yet
return;
}
if (!ClientRelativeInstances[clientId].ContainsKey(NetworkObjectId))
{
// exit early if the client hasn't spawned a clone of this instance yet
return;
}
if (clientId == NetworkManager.LocalClientId)
{
continue;
}
// This should happen shortly afte the instances spawns (based on the deferred despawn count)
if (!IsRoot && !ClientRelativeInstances[clientId][NetworkObjectId].WasContactedByPeviousChainMember)
{
// exit early if the non-authority instance has not been contacted yet
return;
}
}
// If we made it here, then defer despawn this instance
InvokeDespawn();
m_DeferredDespawn = true;
}
private void Log(string message)
{
if (!EnableVerbose)
{
return;
}
Debug.Log($"[{name}][Client-{NetworkManager.LocalClientId}][{NetworkObjectId}] {message}");
}
}
}

11
Tests/Runtime/DistributedAuthority/DeferredDespawningTests.cs.meta Normal file
View File

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

520
Tests/Runtime/DistributedAuthority/DistributeObjectsTests.cs Normal file
View File

@@ -0,0 +1,520 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NUnit.Framework;
using Unity.Netcode.Components;
using Unity.Netcode.TestHelpers.Runtime;
using Unity.Netcode.Transports.UTP;
using UnityEngine;
using UnityEngine.TestTools;
using Random = UnityEngine.Random;
namespace Unity.Netcode.RuntimeTests
{
/// <summary>
/// Validates that distributable NetworkObjects are distributed upon
/// a client connecting or disconnecting.
/// </summary>
public class DistributeObjectsTests : IntegrationTestWithApproximation
{
private GameObject m_DistributeObject;
private StringBuilder m_ErrorLog = new StringBuilder();
private const int k_LateJoinClientCount = 4;
protected override int NumberOfClients => 0;
public DistributeObjectsTests() : base(HostOrServer.DAHost)
{
}
protected override IEnumerator OnSetup()
{
m_ObjectToValidate = null;
return base.OnSetup();
}
protected override void OnServerAndClientsCreated()
{
var serverTransport = m_ServerNetworkManager.NetworkConfig.NetworkTransport as UnityTransport;
// I hate having to add time to our tests, but in case a VM is running slow the disconnect timeout needs to be reasonably high
serverTransport.DisconnectTimeoutMS = 1000;
m_DistributeObject = CreateNetworkObjectPrefab("DisObject");
m_DistributeObject.AddComponent<DistributeObjectsTestHelper>();
m_DistributeObject.AddComponent<DistributeTestTransform>();
// Set baseline to be distributable
var networkObject = m_DistributeObject.GetComponent<NetworkObject>();
networkObject.SetOwnershipStatus(NetworkObject.OwnershipStatus.Distributable);
networkObject.DontDestroyWithOwner = true;
base.OnServerAndClientsCreated();
}
protected override IEnumerator OnServerAndClientsConnected()
{
m_ServerNetworkManager.SpawnManager.EnableDistributeLogging = m_EnableVerboseDebug;
m_ServerNetworkManager.ConnectionManager.EnableDistributeLogging = m_EnableVerboseDebug;
return base.OnServerAndClientsConnected();
}
private NetworkObject m_ObjectToValidate;
private bool ValidateObjectSpawnedOnAllClients()
{
m_ErrorLog.Clear();
var networkObjectId = m_ObjectToValidate.NetworkObjectId;
var name = m_ObjectToValidate.name;
if (!UseCMBService() && !m_ServerNetworkManager.SpawnManager.SpawnedObjects.ContainsKey(networkObjectId))
{
m_ErrorLog.Append($"Client-{m_ServerNetworkManager.LocalClientId} has not spawned {name}!");
return false;
}
foreach (var client in m_ClientNetworkManagers)
{
if (!client.SpawnManager.SpawnedObjects.ContainsKey(networkObjectId))
{
m_ErrorLog.Append($"Client-{client.LocalClientId} has not spawned {name}!");
return false;
}
}
return true;
}
private const int k_ObjectCount = 20;
private bool ValidateDistributedObjectsSpawned(bool lateJoining)
{
m_ErrorLog.Clear();
var hostId = m_ServerNetworkManager.LocalClientId;
if (!DistributeObjectsTestHelper.DistributedObjects.ContainsKey(hostId))
{
m_ErrorLog.AppendLine($"[Client-{hostId}] Does not have an entry in the root of the {nameof(DistributeObjectsTestHelper.DistributedObjects)} table!");
return false;
}
var daHostObjectTracking = DistributeObjectsTestHelper.DistributedObjects[hostId];
if (!daHostObjectTracking.ContainsKey(hostId))
{
m_ErrorLog.AppendLine($"[Client-{hostId}] Does not have a local an entry in the {nameof(DistributeObjectsTestHelper.DistributedObjects)} table!");
return false;
}
var daHostObjects = daHostObjectTracking[hostId];
var expected = 0;
if (lateJoining)
{
expected = k_ObjectCount / (m_ClientNetworkManagers.Count() + 1);
}
else
{
expected = k_ObjectCount / (m_ClientNetworkManagers.Where((c) => c.IsConnectedClient).Count() + 1);
}
// It should theoretically be the expected or...
if (daHostObjects.Count != expected)
{
// due to not rounding one more than the expected
expected++;
if (daHostObjects.Count != expected)
{
m_ErrorLog.AppendLine($"[Client-{hostId}][General] Expected {expected} spawned objects, but only {daHostObjects.Count} exist!");
return false;
}
}
foreach (var networkObject in daHostObjects)
{
m_ObjectToValidate = networkObject.Value;
if (!ValidateObjectSpawnedOnAllClients())
{
m_ErrorLog.AppendLine($"[{m_ObjectToValidate.name}] Was not spawned on all clients!");
return false;
}
}
return true;
}
private bool ValidateOwnershipTablesMatch()
{
m_ErrorLog.Clear();
var hostId = m_ServerNetworkManager.LocalClientId;
var expectedEntries = m_ClientNetworkManagers.Where((c) => c.IsListening && c.IsConnectedClient).Count() + 1;
// Make sure all clients have an table created
if (DistributeObjectsTestHelper.DistributedObjects.Count < expectedEntries)
{
m_ErrorLog.AppendLine($"[General] Expected {expectedEntries} entries in the root of the {nameof(DistributeObjectsTestHelper.DistributedObjects)} table but only {DistributeObjectsTestHelper.DistributedObjects.Count} exist!");
return false;
}
if (!DistributeObjectsTestHelper.DistributedObjects.ContainsKey(hostId))
{
m_ErrorLog.AppendLine($"[Client-{hostId}] Does not have an entry in the root of the {nameof(DistributeObjectsTestHelper.DistributedObjects)} table!");
return false;
}
var daHostEntries = DistributeObjectsTestHelper.DistributedObjects[hostId];
if (!daHostEntries.ContainsKey(hostId))
{
m_ErrorLog.AppendLine($"[Client-{hostId}] Does not have a local an entry in the {nameof(DistributeObjectsTestHelper.DistributedObjects)} table!");
return false;
}
var clients = m_ServerNetworkManager.ConnectedClientsIds.ToList();
clients.Remove(0);
// Cycle through each client's entry on the DAHost to run a comparison
foreach (var hostClientEntry in daHostEntries)
{
foreach (var ownerEntry in hostClientEntry.Value)
{
foreach (var client in clients)
{
var clientOwnerTable = DistributeObjectsTestHelper.DistributedObjects[client];
if (!clientOwnerTable.ContainsKey(hostClientEntry.Key))
{
m_ErrorLog.AppendLine($"[Client-{client}] No ownership table exists the client relative section of the {nameof(DistributeObjectsTestHelper.DistributedObjects)} table!");
return false;
}
var clientEntry = clientOwnerTable[hostClientEntry.Key];
if (!clientEntry.ContainsKey(ownerEntry.Key))
{
m_ErrorLog.AppendLine($"[Client-{client}] {ownerEntry.Value.name} does not exists in Client-{client}'s sub-section for Owner-{hostClientEntry.Key} relative section of the {nameof(DistributeObjectsTestHelper.DistributedObjects)} table!");
return false;
}
var clientObjectEntry = clientEntry[ownerEntry.Key];
if (clientObjectEntry.OwnerClientId != ownerEntry.Value.OwnerClientId)
{
m_ErrorLog.AppendLine($"[Client-{client}][Owner Mismatch] {clientObjectEntry.OwnerClientId} does equal {ownerEntry.Value.OwnerClientId}!");
return false;
}
// Assure the observers match
foreach (var observer in ownerEntry.Value.Observers)
{
if (!clientObjectEntry.Observers.Contains(observer))
{
m_ErrorLog.AppendLine($"[Client-{client}][Observer Mismatch] {nameof(NetworkObject)} {clientObjectEntry.name}'s observers does not contain {observer}, but the authority instance does!");
return false;
}
}
}
}
}
return true;
}
private bool ValidateTransformsMatch()
{
m_ErrorLog.Clear();
var hostId = m_ServerNetworkManager.LocalClientId;
var daHostEntries = DistributeObjectsTestHelper.DistributedObjects[hostId];
var clients = m_ServerNetworkManager.ConnectedClientsIds.ToList();
foreach (var clientOwner in daHostEntries.Keys)
{
// Cycle through the owner's objects
foreach (var entry in DistributeObjectsTestHelper.DistributedObjects[clientOwner][clientOwner].Values)
{
var ownerTestTransform = entry.GetComponent<DistributeTestTransform>();
// Compare against the other client instances of that object
foreach (var client in clients)
{
if (client == clientOwner)
{
continue;
}
var clientObjectInstance = DistributeObjectsTestHelper.DistributedObjects[client][clientOwner][entry.NetworkObjectId];
if (!ownerTestTransform.IsPositionClose(clientObjectInstance.transform.position))
{
m_ErrorLog.AppendLine($"[Position Mismatch] Client-{client} Instance: {GetVector3Values(clientObjectInstance.transform.position)} != Owner Instance: {GetVector3Values(ownerTestTransform.transform.position)}!");
return false;
}
}
}
}
return true;
}
protected override void OnNewClientCreated(NetworkManager networkManager)
{
networkManager.NetworkConfig.Prefabs = m_ServerNetworkManager.NetworkConfig.Prefabs;
base.OnNewClientCreated(networkManager);
}
private bool SpawnCountsMatch()
{
var passed = true;
var spawnCount = 0;
m_ErrorLog.Clear();
if (!UseCMBService())
{
spawnCount = m_ServerNetworkManager.SpawnManager.SpawnedObjects.Count;
}
else
{
spawnCount = m_ClientNetworkManagers[0].SpawnManager.SpawnedObjects.Count;
}
foreach (var client in m_ClientNetworkManagers)
{
var clientCount = client.SpawnManager.SpawnedObjects.Count;
if (clientCount != spawnCount)
{
m_ErrorLog.AppendLine($"[Client-{client.LocalClientId}] Has a spawn count of {clientCount} but {spawnCount} was expected!");
passed = false;
}
}
return passed;
}
/// <summary>
/// This is a straight forward validation for the distribution of NetworkObjects
/// upon a client connecting or disconnecting. It also validates that the observers
/// on each non-authority instance matches the authority instance's. Finally, it
/// also includes validation that NetworkTransform updates continue to update and
/// synchronize properly after ownership for a set number of objects has changed.
/// </summary>
[UnityTest]
public IEnumerator DistributeNetworkObjects()
{
for (int i = 0; i < k_ObjectCount; i++)
{
SpawnObject(m_DistributeObject, m_ServerNetworkManager);
}
// Validate NetworkObjects get redistributed properly when a client joins
for (int j = 0; j < k_LateJoinClientCount; j++)
{
yield return CreateAndStartNewClient();
yield return WaitForConditionOrTimeOut(() => ValidateDistributedObjectsSpawned(true));
AssertOnTimeout($"[Client-{j + 1}][Initial Spawn] Not all clients spawned all objects!\n {m_ErrorLog}");
yield return WaitForConditionOrTimeOut(ValidateOwnershipTablesMatch);
AssertOnTimeout($"[Client-{j + 1}][OnwershipTable Mismatch] {m_ErrorLog}");
// When ownership changes, the new owner will randomly pick a new target to move towards and will move towards the target.
// Validate all other instances of the NetworkObjects that have had newly assigned owners have matching positions to the
// newly assigned owenr's instance.
yield return WaitForConditionOrTimeOut(ValidateTransformsMatch);
AssertOnTimeout($"[Client-{j + 1}][Transform Mismatch] {m_ErrorLog}");
DisplayOwnership();
yield return WaitForConditionOrTimeOut(SpawnCountsMatch);
AssertOnTimeout($"[Spawn Count Mismatch] {m_ErrorLog}");
}
// Validate NetworkObjects get redistributed properly when a client disconnects
for (int j = k_LateJoinClientCount - 1; j >= 0; j--)
{
var client = m_ClientNetworkManagers[j];
// Remove the client from the other clients' ownership tracking table
DistributeObjectsTestHelper.RemoveClient(client.LocalClientId);
// Disconnect the client
yield return StopOneClient(client, true);
//yield return new WaitForSeconds(0.1f);
// Validate all tables match
yield return WaitForConditionOrTimeOut(ValidateOwnershipTablesMatch);
AssertOnTimeout($"[Client-{j + 1}][OnwershipTable Mismatch] {m_ErrorLog}");
// When ownership changes, the new owner will randomly pick a new target to move towards and will move towards the target.
// Validate all other instances of the NetworkObjects that have had newly assigned owners have matching positions to the
// newly assigned owenr's instance.
yield return WaitForConditionOrTimeOut(ValidateTransformsMatch);
AssertOnTimeout($"[Client-{j + 1}][Transform Mismatch] {m_ErrorLog}");
// DANGO-TODO: Make this tied to verbose mode once we know the CMB Service integration works properly
DisplayOwnership();
yield return WaitForConditionOrTimeOut(SpawnCountsMatch);
AssertOnTimeout($"[Spawn Count Mismatch] {m_ErrorLog}");
}
}
private void DisplayOwnership()
{
m_ErrorLog.Clear();
var daHostEntries = DistributeObjectsTestHelper.DistributedObjects[0];
foreach (var entry in daHostEntries)
{
m_ErrorLog.AppendLine($"[Client-{entry.Key}][Owned Objects: {entry.Value.Count}]");
}
VerboseDebug($"{m_ErrorLog}");
}
/// <summary>
/// This keeps track of each clients perspective of which NetworkObjects are owned by which client.
/// It is used to validate that all clients are in synch with ownership updates.
/// </summary>
public class DistributeObjectsTestHelper : NetworkBehaviour
{
/// <summary>
/// [Client Context][Client Owners][NetworkObjectId][NetworkObject]
/// </summary>
public static Dictionary<ulong, Dictionary<ulong, Dictionary<ulong, NetworkObject>>> DistributedObjects = new Dictionary<ulong, Dictionary<ulong, Dictionary<ulong, NetworkObject>>>();
public static void RemoveClient(ulong clientId)
{
foreach (var clients in DistributedObjects.Values)
{
clients.Remove(clientId);
}
DistributedObjects.Remove(clientId);
}
internal ulong ClientId;
public override void OnNetworkSpawn()
{
ClientId = NetworkManager.LocalClientId;
UpdateOwnerTableAdd();
base.OnNetworkSpawn();
}
private void UpdateOwnerTableAdd()
{
if (!DistributedObjects.ContainsKey(ClientId))
{
DistributedObjects.Add(ClientId, new Dictionary<ulong, Dictionary<ulong, NetworkObject>>());
}
if (!DistributedObjects[ClientId].ContainsKey(OwnerClientId))
{
DistributedObjects[ClientId].Add(OwnerClientId, new Dictionary<ulong, NetworkObject>());
}
if (DistributedObjects[ClientId][OwnerClientId].ContainsKey(NetworkObject.NetworkObjectId))
{
throw new Exception($"[Client-{ClientId}][{name}] {nameof(NetworkObject)} already exists in Client-{ClientId}'s " +
$"DistributedObjects being tracking under Client-{OwnerClientId}'s list of owned {nameof(NetworkObject)}s!");
}
DistributedObjects[ClientId][OwnerClientId].Add(NetworkObject.NetworkObjectId, NetworkObject);
}
private void UpdateOwnerTableRemove(ulong previous)
{
// This does not need to exist when first starting, but will (at one point in testing)
// become valid.
if (DistributedObjects[ClientId].ContainsKey(previous))
{
if (DistributedObjects[ClientId][previous].ContainsKey(NetworkObject.NetworkObjectId))
{
DistributedObjects[ClientId][previous].Remove(NetworkObject.NetworkObjectId);
}
}
}
protected override void OnOwnershipChanged(ulong previous, ulong current)
{
// At start, if NetworkSpawn has not been completed the local client ignores this
if (!DistributedObjects.ContainsKey(ClientId))
{
return;
}
UpdateOwnerTableRemove(previous);
UpdateOwnerTableAdd();
base.OnOwnershipChanged(previous, current);
}
}
/// <summary>
/// This is used to validate that upon distributed ownership changes NetworkTransform sycnhronization
/// still works properly.
/// </summary>
public class DistributeTestTransform : NetworkTransform
{
private float m_DeltaVarPosition = 0.15f;
private float m_DeltaVarQauternion = 0.015f;
protected Vector3 GetRandomVector3(float min, float max, Vector3 baseLine, bool randomlyApplySign = false)
{
var retValue = new Vector3(baseLine.x * Random.Range(min, max), baseLine.y * Random.Range(min, max), baseLine.z * Random.Range(min, max));
if (!randomlyApplySign)
{
return retValue;
}
retValue.x *= Random.Range(1, 100) >= 50 ? -1 : 1;
retValue.y *= Random.Range(1, 100) >= 50 ? -1 : 1;
retValue.z *= Random.Range(1, 100) >= 50 ? -1 : 1;
return retValue;
}
protected override bool OnIsServerAuthoritative()
{
var isOwnerAuth = base.OnIsServerAuthoritative();
Assert.IsFalse(isOwnerAuth, $"Base {nameof(NetworkTransform)} did not automatically return false in distributed authority mode!");
return isOwnerAuth;
}
public override void OnNetworkSpawn()
{
base.OnNetworkSpawn();
if (CanCommitToTransform)
{
var randomPos = GetRandomVector3(1.0f, 10.0f, Vector3.one, true);
SetState(randomPos, null, null, false);
m_TargetPosition = randomPos;
}
}
private Vector3 m_TargetPosition;
private Vector3 m_DirToTarget;
private bool m_ReachedTarget;
protected override void OnOwnershipChanged(ulong previous, ulong current)
{
base.OnOwnershipChanged(previous, current);
m_TargetPosition = transform.position + GetRandomVector3(4.0f, 8.0f, Vector3.one, true);
m_DirToTarget = (m_TargetPosition - transform.position).normalized;
m_ReachedTarget = false;
}
protected override void Update()
{
base.Update();
if (CanCommitToTransform)
{
if (!m_ReachedTarget)
{
var distance = Vector3.Distance(transform.position, m_TargetPosition);
var speed = Mathf.Clamp(distance, 0.10f, 2.0f);
transform.position += m_DirToTarget * speed * Time.deltaTime;
m_ReachedTarget = IsPositionClose(m_TargetPosition);
}
}
}
public bool IsPositionClose(Vector3 position)
{
return Approximately(transform.position, position);
}
protected bool Approximately(Vector3 a, Vector3 b)
{
var deltaVariance = m_DeltaVarPosition;
return Math.Round(Mathf.Abs(a.x - b.x), 2) <= deltaVariance &&
Math.Round(Mathf.Abs(a.y - b.y), 2) <= deltaVariance &&
Math.Round(Mathf.Abs(a.z - b.z), 2) <= deltaVariance;
}
protected bool Approximately(Quaternion a, Quaternion b)
{
var deltaVariance = m_DeltaVarQauternion;
return Mathf.Abs(a.x - b.x) <= deltaVariance &&
Mathf.Abs(a.y - b.y) <= deltaVariance &&
Mathf.Abs(a.z - b.z) <= deltaVariance &&
Mathf.Abs(a.w - b.w) <= deltaVariance;
}
}
}
}

11
Tests/Runtime/DistributedAuthority/DistributeObjectsTests.cs.meta Normal file
View File

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

718
Tests/Runtime/DistributedAuthority/DistributedAuthorityCodecTests.cs Normal file
View File

@@ -0,0 +1,718 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using NUnit.Framework;
using Unity.Collections;
using Unity.Netcode.TestHelpers.Runtime;
using Unity.Netcode.Transports.UTP;
#if UTP_TRANSPORT_2_0_ABOVE
using Unity.Networking.Transport;
#endif
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.TestTools;
namespace Unity.Netcode.RuntimeTests
{
public class DistributedAuthorityCodecTests : NetcodeIntegrationTest
{
protected override int NumberOfClients => 1;
// Use the CMB Service for all tests
protected override bool UseCMBService() => true;
// Set the session mode to distributed authority for all tests
protected override SessionModeTypes OnGetSessionmode() => SessionModeTypes.DistributedAuthority;
private CodecTestHooks m_ClientCodecHook;
private NetworkManager Client => m_ClientNetworkManagers[0];
private string m_TransportHost = Environment.GetEnvironmentVariable("NGO_HOST") ?? "127.0.0.1";
private const int k_TransportPort = 7777;
private const int k_ClientId = 0;
private GameObject m_SpawnObject;
public class TestNetworkComponent : NetworkBehaviour
{
public NetworkList<int> MyNetworkList = new NetworkList<int>(new List<int> { 1, 2, 3 });
[Rpc(SendTo.NotAuthority)]
public void TestNotAuthorityRpc(byte[] _)
{
}
[Rpc(SendTo.Authority)]
public void TestAuthorityRpc(byte[] _)
{
}
}
protected override void OnOneTimeSetup()
{
// Prevents the tests from running if no CMB Service is detected
#if !UTP_TRANSPORT_2_0_ABOVE
Assert.Ignore("ignoring DA codec tests because UTP transport must be 2.0");
#else
if (!CanConnectToServer(m_TransportHost, k_TransportPort))
{
Assert.Ignore("ignoring DA codec tests because UTP transport cannot connect to the runtime");
}
#endif
base.OnOneTimeSetup();
}
/// <summary>
/// Add any additional components to default player prefab
/// </summary>
protected override void OnCreatePlayerPrefab()
{
m_PlayerPrefab.AddComponent<TestNetworkComponent>();
base.OnCreatePlayerPrefab();
}
/// <summary>
/// Modify NetworkManager instances for settings specific to tests
/// </summary>
protected override void OnServerAndClientsCreated()
{
var utpTransport = Client.gameObject.AddComponent<UnityTransport>();
Client.NetworkConfig.NetworkTransport = utpTransport;
Client.NetworkConfig.EnableSceneManagement = false;
Client.NetworkConfig.AutoSpawnPlayerPrefabClientSide = true;
utpTransport.ConnectionData.Address = Dns.GetHostAddresses(m_TransportHost).First().ToString();
utpTransport.ConnectionData.Port = k_TransportPort;
Client.LogLevel = LogLevel.Developer;
// Validate we are in distributed authority mode with client side spawning and using CMB Service
Assert.True(Client.DistributedAuthorityMode, "Distributed authority is not set!");
Assert.True(Client.AutoSpawnPlayerPrefabClientSide, "Client side spawning is not set!");
Assert.True(Client.CMBServiceConnection, "CMBServiceConnection is not set!");
// Create a prefab for creating and destroying tests (auto-registers with NetworkManagers)
m_SpawnObject = CreateNetworkObjectPrefab("TestObject");
m_SpawnObject.AddComponent<TestNetworkComponent>();
// Ignore the client connection timeout after starting the client
m_BypassConnectionTimeout = true;
}
protected override IEnumerator OnStartedServerAndClients()
{
// Register hooks after starting clients and server (in this case just the one client)
// We do this at this point in time because the MessageManager exists (happens within the same call stack when starting NetworkManagers)
m_ClientCodecHook = new CodecTestHooks();
Client.MessageManager.Hook(m_ClientCodecHook);
yield return base.OnStartedServerAndClients();
// wait for client to connect since m_BypassConnectionTimeout
yield return WaitForConditionOrTimeOut(() => Client.LocalClient.PlayerObject != null);
AssertOnTimeout($"Timed out waiting for the client's player to be spanwed!");
}
[UnityTest]
public IEnumerator AuthorityRpc()
{
var player = Client.LocalClient.PlayerObject;
player.OwnerClientId = Client.LocalClientId + 1;
var networkComponent = player.GetComponent<TestNetworkComponent>();
networkComponent.UpdateNetworkProperties();
networkComponent.TestAuthorityRpc(new byte[] { 1, 2, 3, 4 });
// Universal Rpcs are sent as a ProxyMessage (which contains an RpcMessage)
yield return m_ClientCodecHook.WaitForMessageReceived<ProxyMessage>();
}
[UnityTest]
public IEnumerator ChangeOwnership()
{
var message = new ChangeOwnershipMessage
{
DistributedAuthorityMode = true,
NetworkObjectId = 100,
OwnerClientId = 2,
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator ClientConnected()
{
var message = new ClientConnectedMessage()
{
ClientId = 2,
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator ClientDisconnected()
{
var message = new ClientDisconnectedMessage()
{
ClientId = 2,
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator CreateObject()
{
SpawnObject(m_SpawnObject, Client);
yield return m_ClientCodecHook.WaitForMessageReceived<CreateObjectMessage>();
}
[UnityTest]
public IEnumerator DestroyObject()
{
var spawnedObject = SpawnObject(m_SpawnObject, Client);
yield return m_ClientCodecHook.WaitForMessageReceived<CreateObjectMessage>();
spawnedObject.GetComponent<NetworkObject>().Despawn();
yield return m_ClientCodecHook.WaitForMessageReceived<DestroyObjectMessage>();
}
[UnityTest]
public IEnumerator Disconnect()
{
var message = new DisconnectReasonMessage
{
Reason = "test"
};
return SendMessage(ref message);
}
[UnityTest]
public IEnumerator NamedMessage()
{
var writeBuffer = new FastBufferWriter(sizeof(int), Allocator.Temp);
writeBuffer.WriteValueSafe(5);
var message = new NamedMessage
{
Hash = 3,
SendData = writeBuffer,
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator NetworkVariableDelta()
{
var message = new NetworkVariableDeltaMessage
{
NetworkObjectId = 0,
NetworkBehaviourIndex = 1,
DeliveryMappedNetworkVariableIndex = new HashSet<int> { 2, 3, 4 },
TargetClientId = 5,
NetworkBehaviour = Client.LocalClient.PlayerObject.GetComponent<TestNetworkComponent>(),
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator NotAuthorityRpc()
{
Client.LocalClient.PlayerObject.GetComponent<TestNetworkComponent>().TestNotAuthorityRpc(new byte[] { 1, 2, 3, 4 });
// Universal Rpcs are sent as a ProxyMessage (which contains an RpcMessage)
yield return m_ClientCodecHook.WaitForMessageReceived<ProxyMessage>();
}
[UnityTest]
public IEnumerator ParentSync()
{
var message = new ParentSyncMessage
{
NetworkObjectId = 0,
WorldPositionStays = true,
IsLatestParentSet = false,
Position = new Vector3(1, 2, 3),
Rotation = new Quaternion(4, 5, 6, 7),
Scale = new Vector3(8, 9, 10),
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator SessionOwner()
{
var message = new SessionOwnerMessage()
{
SessionOwner = 2,
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator ServerLog()
{
var message = new ServerLogMessage()
{
LogType = NetworkLog.LogType.Info,
Message = "test",
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator UnnamedMessage()
{
var writeBuffer = new FastBufferWriter(sizeof(int), Allocator.Temp);
writeBuffer.WriteValueSafe(5);
var message = new UnnamedMessage
{
SendData = writeBuffer,
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator SceneEventMessageLoad()
{
Client.SceneManager.SkipSceneHandling = true;
var eventData = new SceneEventData(Client)
{
SceneEventType = SceneEventType.Load,
LoadSceneMode = LoadSceneMode.Single,
SceneEventProgressId = Guid.NewGuid(),
SceneHash = XXHash.Hash32("SomeRandomSceneName"),
SceneHandle = 23456,
};
var message = new SceneEventMessage()
{
EventData = eventData
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator SceneEventMessageLoadWithObjects()
{
Client.SceneManager.SkipSceneHandling = true;
var prefabNetworkObject = m_SpawnObject.GetComponent<NetworkObject>();
Client.SceneManager.ScenePlacedObjects.Add(0, new Dictionary<int, NetworkObject>()
{
{ 1, prefabNetworkObject }
});
var eventData = new SceneEventData(Client)
{
SceneEventType = SceneEventType.Load,
LoadSceneMode = LoadSceneMode.Single,
SceneEventProgressId = Guid.NewGuid(),
SceneHash = XXHash.Hash32("SomeRandomSceneName"),
SceneHandle = 23456,
};
var message = new SceneEventMessage()
{
EventData = eventData
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator SceneEventMessageUnload()
{
Client.SceneManager.SkipSceneHandling = true;
var eventData = new SceneEventData(Client)
{
SceneEventType = SceneEventType.Unload,
LoadSceneMode = LoadSceneMode.Single,
SceneEventProgressId = Guid.NewGuid(),
SceneHash = XXHash.Hash32("SomeRandomSceneName"),
SceneHandle = 23456,
};
var message = new SceneEventMessage()
{
EventData = eventData
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator SceneEventMessageLoadComplete()
{
Client.SceneManager.SkipSceneHandling = true;
var eventData = new SceneEventData(Client)
{
SceneEventType = SceneEventType.LoadComplete,
LoadSceneMode = LoadSceneMode.Single,
SceneEventProgressId = Guid.NewGuid(),
SceneHash = XXHash.Hash32("SomeRandomSceneName"),
SceneHandle = 23456,
};
var message = new SceneEventMessage()
{
EventData = eventData
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator SceneEventMessageUnloadComplete()
{
Client.SceneManager.SkipSceneHandling = true;
var eventData = new SceneEventData(Client)
{
SceneEventType = SceneEventType.UnloadComplete,
LoadSceneMode = LoadSceneMode.Single,
SceneEventProgressId = Guid.NewGuid(),
SceneHash = XXHash.Hash32("SomeRandomSceneName"),
SceneHandle = 23456,
};
var message = new SceneEventMessage()
{
EventData = eventData
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator SceneEventMessageLoadCompleted()
{
Client.SceneManager.SkipSceneHandling = true;
var eventData = new SceneEventData(Client)
{
SceneEventType = SceneEventType.LoadEventCompleted,
LoadSceneMode = LoadSceneMode.Single,
SceneEventProgressId = Guid.NewGuid(),
SceneHash = XXHash.Hash32("SomeRandomSceneName"),
SceneHandle = 23456,
ClientsCompleted = new List<ulong>() { k_ClientId },
ClientsTimedOut = new List<ulong>() { 123456789 },
};
var message = new SceneEventMessage()
{
EventData = eventData
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator SceneEventMessageUnloadLoadCompleted()
{
Client.SceneManager.SkipSceneHandling = true;
var eventData = new SceneEventData(Client)
{
SceneEventType = SceneEventType.UnloadEventCompleted,
LoadSceneMode = LoadSceneMode.Single,
SceneEventProgressId = Guid.NewGuid(),
SceneHash = XXHash.Hash32("SomeRandomSceneName"),
SceneHandle = 23456,
ClientsCompleted = new List<ulong>() { k_ClientId },
ClientsTimedOut = new List<ulong>() { 123456789 },
};
var message = new SceneEventMessage()
{
EventData = eventData
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator SceneEventMessageSynchronize()
{
Client.SceneManager.SkipSceneHandling = true;
var eventData = new SceneEventData(Client)
{
SceneEventType = SceneEventType.Synchronize,
LoadSceneMode = LoadSceneMode.Single,
ClientSynchronizationMode = LoadSceneMode.Single,
SceneHash = XXHash.Hash32("SomeRandomSceneName"),
SceneHandle = 23456,
ScenesToSynchronize = new Queue<uint>()
};
eventData.ScenesToSynchronize.Enqueue(101);
eventData.SceneHandlesToSynchronize = new Queue<uint>();
eventData.SceneHandlesToSynchronize.Enqueue(202);
var message = new SceneEventMessage()
{
EventData = eventData
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator SceneEventMessageReSynchronize()
{
Client.SceneManager.SkipSceneHandling = true;
var eventData = new SceneEventData(Client)
{
SceneEventType = SceneEventType.ReSynchronize,
LoadSceneMode = LoadSceneMode.Single,
ClientSynchronizationMode = LoadSceneMode.Single,
SceneHash = XXHash.Hash32("SomeRandomSceneName"),
SceneHandle = 23456,
};
var message = new SceneEventMessage()
{
EventData = eventData
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator SceneEventMessageSynchronizeComplete()
{
Client.SceneManager.SkipSceneHandling = true;
var eventData = new SceneEventData(Client)
{
SceneEventType = SceneEventType.ReSynchronize,
LoadSceneMode = LoadSceneMode.Single,
ClientSynchronizationMode = LoadSceneMode.Single,
SceneHash = XXHash.Hash32("SomeRandomSceneName"),
SceneHandle = 23456,
};
var message = new SceneEventMessage()
{
EventData = eventData
};
yield return SendMessage(ref message);
}
[UnityTest]
public IEnumerator SceneEventMessageActiveSceneChanged()
{
Client.SceneManager.SkipSceneHandling = true;
var eventData = new SceneEventData(Client)
{
SceneEventType = SceneEventType.ActiveSceneChanged,
ActiveSceneHash = XXHash.Hash32("ActiveScene")
};
var message = new SceneEventMessage()
{
EventData = eventData
};
yield return SendMessage(ref message);
}
[UnityTest, Ignore("Serializing twice causes data to disappear in the SceneManager for this event")]
public IEnumerator SceneEventMessageObjectSceneChanged()
{
Client.SceneManager.SkipSceneHandling = true;
var prefabNetworkObject = m_SpawnObject.GetComponent<NetworkObject>();
Client.SceneManager.ObjectsMigratedIntoNewScene = new Dictionary<int, Dictionary<ulong, List<NetworkObject>>>
{
{ 0, new Dictionary<ulong, List<NetworkObject>>()}
};
Client.SceneManager.ObjectsMigratedIntoNewScene[0].Add(Client.LocalClientId, new List<NetworkObject>() { prefabNetworkObject });
var eventData = new SceneEventData(Client)
{
SceneEventType = SceneEventType.ObjectSceneChanged,
};
var message = new SceneEventMessage()
{
EventData = eventData
};
yield return SendMessage(ref message);
}
private IEnumerator SendMessage<T>(ref T message) where T : INetworkMessage
{
Client.MessageManager.SetVersion(k_ClientId, XXHash.Hash32(typeof(T).FullName), 0);
var clientIds = new NativeArray<ulong>(1, Allocator.Temp);
clientIds[0] = k_ClientId;
Client.MessageManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientIds);
Client.MessageManager.ProcessSendQueues();
return m_ClientCodecHook.WaitForMessageReceived(message);
}
#if UTP_TRANSPORT_2_0_ABOVE
private static bool CanConnectToServer(string host, ushort port, double timeoutMs = 100)
{
var address = Dns.GetHostAddresses(host).First();
var endpoint = NetworkEndpoint.Parse(address.ToString(), port);
var driver = NetworkDriver.Create();
var connection = driver.Connect(endpoint);
var start = DateTime.Now;
var ev = Networking.Transport.NetworkEvent.Type.Empty;
while (ev != Networking.Transport.NetworkEvent.Type.Connect)
{
driver.ScheduleUpdate().Complete();
ev = driver.PopEventForConnection(connection, out _, out _);
if (DateTime.Now - start > TimeSpan.FromMilliseconds(timeoutMs))
{
return false;
}
}
driver.Disconnect(connection);
return true;
}
#endif
}
internal class CodecTestHooks : INetworkHooks
{
private Dictionary<string, Queue<TestMessage>> m_ExpectedMessages = new Dictionary<string, Queue<TestMessage>>();
private Dictionary<string, HashSet<string>> m_ReceivedMessages = new Dictionary<string, HashSet<string>>();
private struct TestMessage
{
public string Name;
public byte[] Data;
}
public void OnBeforeSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery) where T : INetworkMessage
{
if (message is ConnectionRequestMessage)
{
return;
}
var writer = new FastBufferWriter(1024, Allocator.Temp);
message.Serialize(writer, 0);
var testName = TestContext.CurrentContext.Test.Name;
if (!m_ExpectedMessages.ContainsKey(testName))
{
m_ExpectedMessages[testName] = new Queue<TestMessage>();
}
m_ExpectedMessages[testName].Enqueue(new TestMessage
{
Name = typeof(T).ToString(),
Data = writer.ToArray(),
});
writer.Dispose();
}
public void OnAfterSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery, int messageSizeBytes) where T : INetworkMessage
{
}
public void OnBeforeReceiveMessage(ulong senderId, Type messageType, int messageSizeBytes)
{
}
public void OnAfterReceiveMessage(ulong senderId, Type messageType, int messageSizeBytes)
{
}
public void OnBeforeSendBatch(ulong clientId, int messageCount, int batchSizeInBytes, NetworkDelivery delivery)
{
}
public void OnAfterSendBatch(ulong clientId, int messageCount, int batchSizeInBytes, NetworkDelivery delivery)
{
}
public void OnBeforeReceiveBatch(ulong senderId, int messageCount, int batchSizeInBytes)
{
}
public void OnAfterReceiveBatch(ulong senderId, int messageCount, int batchSizeInBytes)
{
}
public bool OnVerifyCanSend(ulong destinationId, Type messageType, NetworkDelivery delivery)
{
return true;
}
public bool OnVerifyCanReceive(ulong senderId, Type messageType, FastBufferReader messageContent, ref NetworkContext context)
{
if (messageType == typeof(ConnectionApprovedMessage))
{
return true;
}
var testName = TestContext.CurrentContext.Test.Name;
Assert.True(m_ExpectedMessages.ContainsKey(testName));
Assert.IsNotEmpty(m_ExpectedMessages[testName]);
var nextMessage = m_ExpectedMessages[testName].Dequeue();
Assert.AreEqual(messageType.ToString(), nextMessage.Name, $"received unexpected message type: {messageType}");
if (!m_ReceivedMessages.ContainsKey(testName))
{
m_ReceivedMessages[testName] = new HashSet<string>();
}
m_ReceivedMessages[testName].Add(messageType.ToString());
// ServerLogMessage is an exception - it gets decoded correctly, but the bytes from the runtime do not directly match those sent by the SDK.
if (messageType == typeof(ServerLogMessage))
{
return true;
}
var expectedBytes = nextMessage.Data;
var receivedBytes = messageContent.ToArray();
Assert.AreEqual(expectedBytes, receivedBytes);
return true;
}
public void OnBeforeHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage
{
}
public void OnAfterHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage
{
}
public IEnumerator WaitForMessageReceived<T>(float timeout = 5) where T : INetworkMessage
{
var testName = TestContext.CurrentContext.Test.Name;
var messageType = typeof(T).FullName;
var startTime = Time.realtimeSinceStartup;
while ((!m_ReceivedMessages.ContainsKey(testName) || !m_ReceivedMessages[testName].Contains(messageType)) && Time.realtimeSinceStartup - startTime < timeout)
{
yield return null;
}
Assert.True(m_ReceivedMessages.ContainsKey(testName), "failed to receive any messages");
Assert.True(m_ReceivedMessages[testName].Contains(messageType), $"failed to receive {messageType} message, received: {string.Join(", ", m_ReceivedMessages[testName])}");
// Reset received messages
m_ReceivedMessages[testName] = new HashSet<string>();
}
public IEnumerator WaitForMessageReceived<T>(T _, float timeout = 5) where T : INetworkMessage
{
return WaitForMessageReceived<T>(timeout: timeout);
}
}
}

11
Tests/Runtime/DistributedAuthority/DistributedAuthorityCodecTests.cs.meta Normal file
View File

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

298
Tests/Runtime/DistributedAuthority/NetworkClientAndPlayerObjectTests.cs Normal file
View File

@@ -0,0 +1,298 @@
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NUnit.Framework;
using Unity.Netcode.TestHelpers.Runtime;
using UnityEngine;
using UnityEngine.TestTools;
using Random = UnityEngine.Random;
namespace Unity.Netcode.RuntimeTests
{
[TestFixture(HostOrServer.Host)]
[TestFixture(HostOrServer.Server)]
[TestFixture(HostOrServer.DAHost)]
public class NetworkClientAndPlayerObjectTests : NetcodeIntegrationTest
{
private const int k_PlayerPrefabCount = 6;
protected override int NumberOfClients => 2;
private List<GameObject> m_PlayerPrefabs = new List<GameObject>();
private Dictionary<ulong, uint> m_ChangedPlayerPrefabs = new Dictionary<ulong, uint>();
public NetworkClientAndPlayerObjectTests(HostOrServer hostOrServer) : base(hostOrServer)
{
}
protected override IEnumerator OnTearDown()
{
m_PlayerPrefabs.Clear();
return base.OnTearDown();
}
protected override void OnServerAndClientsCreated()
{
m_PlayerPrefabs.Clear();
for (int i = 0; i < k_PlayerPrefabCount; i++)
{
m_PlayerPrefabs.Add(CreateNetworkObjectPrefab($"PlayerPrefab{i}"));
}
base.OnServerAndClientsCreated();
}
protected override void OnNewClientCreated(NetworkManager networkManager)
{
networkManager.NetworkConfig.Prefabs = m_ServerNetworkManager.NetworkConfig.Prefabs;
if (m_DistributedAuthority)
{
networkManager.OnFetchLocalPlayerPrefabToSpawn = FetchPlayerPrefabToSpawn;
}
base.OnNewClientCreated(networkManager);
}
/// <summary>
/// Only for distributed authority mode
/// </summary>
/// <returns>a unique player prefab for the player</returns>
private GameObject FetchPlayerPrefabToSpawn()
{
var prefabObject = GetRandomPlayerPrefab();
var clientId = m_ClientNetworkManagers[m_ClientNetworkManagers.Length - 1].LocalClientId;
m_ChangedPlayerPrefabs.Add(clientId, prefabObject.GlobalObjectIdHash);
return prefabObject.gameObject;
}
private StringBuilder m_ErrorLogLevel3 = new StringBuilder();
private StringBuilder m_ErrorLogLevel2 = new StringBuilder();
private StringBuilder m_ErrorLogLevel1 = new StringBuilder();
private bool ValidateNetworkClient(NetworkClient networkClient)
{
m_ErrorLogLevel3.Clear();
var success = true;
if (networkClient == null)
{
m_ErrorLogLevel3.Append($"[NetworkClient is NULL]");
// Log error
success = false;
}
if (!networkClient.IsConnected)
{
m_ErrorLogLevel3.Append($"[NetworkClient {nameof(NetworkClient.IsConnected)}] is false]");
// Log error
success = false;
}
if (networkClient.PlayerObject == null)
{
m_ErrorLogLevel3.Append($"[NetworkClient {nameof(NetworkClient.PlayerObject)}] is NULL]");
// Log error
success = false;
}
return success;
}
private bool ValidateNetworkManagerNetworkClients(NetworkManager networkManager)
{
var success = true;
m_ErrorLogLevel2.Clear();
// Number of connected clients plus the DAHost
var expectedCount = m_ClientNetworkManagers.Length + (m_UseHost ? 1 : 0);
if (networkManager.ConnectedClients.Count != expectedCount)
{
m_ErrorLogLevel2.Append($"[{nameof(NetworkManager.ConnectedClients)} count: {networkManager.ConnectedClients.Count} vs expected count: {expectedCount}]");
// Log error
success = false;
}
if (m_UseHost && !ValidateNetworkClient(networkManager.LocalClient))
{
m_ErrorLogLevel2.Append($"[Local NetworkClient: --({m_ErrorLogLevel3})--]");
// Log error
success = false;
}
foreach (var networkClient in networkManager.ConnectedClients)
{
// When just running a server, ignore the server's local NetworkClient
if (!m_UseHost && networkManager.IsServer)
{
continue;
}
if (!ValidateNetworkClient(networkManager.LocalClient))
{
// Log error
success = false;
m_ErrorLogLevel2.Append($"[NetworkClient-{networkManager.LocalClientId}: --({m_ErrorLogLevel3})--]");
}
}
return success;
}
private bool AllNetworkClientsValidated()
{
m_ErrorLogLevel1.Clear();
var success = true;
if (!UseCMBService())
{
if (!ValidateNetworkManagerNetworkClients(m_ServerNetworkManager))
{
m_ErrorLogLevel1.AppendLine($"[Client-{m_ServerNetworkManager.LocalClientId}]{m_ErrorLogLevel2}");
// Log error
success = false;
}
}
foreach (var clientNetworkManager in m_ClientNetworkManagers)
{
if (!ValidateNetworkManagerNetworkClients(clientNetworkManager))
{
m_ErrorLogLevel1.AppendLine($"[Client-{clientNetworkManager.LocalClientId}]{m_ErrorLogLevel2}");
// Log error
success = false;
}
}
return success;
}
/// <summary>
/// Validates that all NetworkManager instances have valid NetworkClients for all connected clients
/// Validates the same thing when a client late joins and when a client disconnects.
/// </summary>
[UnityTest]
public IEnumerator ValidateNetworkClients()
{
// Validate the initial clients created
yield return WaitForConditionOrTimeOut(AllNetworkClientsValidated);
AssertOnTimeout($"[Start] Not all NetworkClients were valid!\n{m_ErrorLogLevel1}");
// Late join a player and revalidate all instances
yield return CreateAndStartNewClient();
yield return WaitForConditionOrTimeOut(AllNetworkClientsValidated);
AssertOnTimeout($"[Late Join] Not all NetworkClients were valid!\n{m_ErrorLogLevel1}");
// Disconnect a player and revalidate all instances
var initialCount = m_ClientNetworkManagers.Length;
yield return StopOneClient(m_ClientNetworkManagers[m_ClientNetworkManagers.Length - 1], true);
// Sanity check to assure we removed the NetworkManager from m_ClientNetworkManagers
Assert.False(initialCount == m_ClientNetworkManagers.Length, $"Disconnected player and expected total number of client {nameof(NetworkManager)}s " +
$"to be {initialCount - 1} but it was still {initialCount}!");
yield return WaitForConditionOrTimeOut(AllNetworkClientsValidated);
AssertOnTimeout($"[Client Disconnect] Not all NetworkClients were valid!\n{m_ErrorLogLevel1}");
}
/// <summary>
/// Verify that all NetworkClients are pointing to the correct player object, even if
/// the player object is changed.
/// </summary>
private bool ValidatePlayerObjectOnClients(NetworkManager clientToValidate)
{
m_ErrorLogLevel2.Clear();
var success = true;
var expectedGlobalObjectIdHash = m_ChangedPlayerPrefabs[clientToValidate.LocalClientId];
if (expectedGlobalObjectIdHash != clientToValidate.LocalClient.PlayerObject.GlobalObjectIdHash)
{
m_ErrorLogLevel2.Append($"[Local Prefab Mismatch][Expected GlobalObjectIdHash: {expectedGlobalObjectIdHash} but was {clientToValidate.LocalClient.PlayerObject.GlobalObjectIdHash}]");
success = false;
}
foreach (var client in m_ClientNetworkManagers)
{
if (client == clientToValidate)
{
continue;
}
var remoteNetworkClient = client.ConnectedClients[clientToValidate.LocalClientId];
if (expectedGlobalObjectIdHash != remoteNetworkClient.PlayerObject.GlobalObjectIdHash)
{
m_ErrorLogLevel2.Append($"[Client-{client.LocalClientId} Prefab Mismatch][Expected GlobalObjectIdHash: {expectedGlobalObjectIdHash} but was {remoteNetworkClient.PlayerObject.GlobalObjectIdHash}]");
success = false;
}
}
return success;
}
private bool ValidateAllPlayerObjects()
{
m_ErrorLogLevel1.Clear();
var success = true;
if (m_UseHost && !UseCMBService())
{
if (!ValidatePlayerObjectOnClients(m_ServerNetworkManager))
{
m_ErrorLogLevel1.AppendLine($"[Client-{m_ServerNetworkManager.LocalClientId}]{m_ErrorLogLevel2}");
success = false;
}
}
foreach (var client in m_ClientNetworkManagers)
{
if (!ValidatePlayerObjectOnClients(client))
{
m_ErrorLogLevel1.AppendLine($"[Client-{client.LocalClientId}]{m_ErrorLogLevel2}");
success = false;
}
}
return success;
}
private NetworkObject GetRandomPlayerPrefab()
{
return m_PlayerPrefabs[Random.Range(0, m_PlayerPrefabs.Count() - 1)].GetComponent<NetworkObject>();
}
/// <summary>
/// Validates that when a client changes their player object that all connected client instances mirror the
/// client's new player object.
/// </summary>
[UnityTest]
public IEnumerator ValidatePlayerObjects()
{
// Just do a quick validation for all connected client's NetworkClients
yield return WaitForConditionOrTimeOut(AllNetworkClientsValidated);
AssertOnTimeout($"Not all NetworkClients were valid!\n{m_ErrorLogLevel1}");
// Now, have each client spawn a new player object
m_ChangedPlayerPrefabs.Clear();
var playerInstance = (GameObject)null;
var playerPrefabToSpawn = (NetworkObject)null;
if (m_UseHost)
{
playerPrefabToSpawn = GetRandomPlayerPrefab();
playerInstance = SpawnPlayerObject(playerPrefabToSpawn.gameObject, m_ServerNetworkManager);
m_ChangedPlayerPrefabs.Add(m_ServerNetworkManager.LocalClientId, playerPrefabToSpawn.GlobalObjectIdHash);
}
foreach (var client in m_ClientNetworkManagers)
{
playerPrefabToSpawn = GetRandomPlayerPrefab();
playerInstance = SpawnPlayerObject(playerPrefabToSpawn.gameObject, client);
m_ChangedPlayerPrefabs.Add(client.LocalClientId, playerPrefabToSpawn.GlobalObjectIdHash);
}
// Validate that all connected clients' NetworkClient instances have the correct player object for each connected client
yield return WaitForConditionOrTimeOut(ValidateAllPlayerObjects);
AssertOnTimeout($"[Existing Clients] Not all NetworkClient player objects were valid!\n{m_ErrorLogLevel1}");
// Distributed authority only feature validation (NetworkManager.OnFetchLocalPlayerPrefabToSpawn)
if (m_DistributedAuthority)
{
// Now test the fetch prefab callback to assure that this is working correctly.
// Start a new client and wait for it to connect
yield return CreateAndStartNewClient();
// Do another validation pass.
yield return WaitForConditionOrTimeOut(ValidateAllPlayerObjects);
AssertOnTimeout($"[Late Joined Client] Not all NetworkClient player objects were valid!\n{m_ErrorLogLevel1}");
}
}
}
}

11
Tests/Runtime/DistributedAuthority/NetworkClientAndPlayerObjectTests.cs.meta Normal file
View File

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

406
Tests/Runtime/DistributedAuthority/OwnershipPermissionsTests.cs Normal file
View File

@@ -0,0 +1,406 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using NUnit.Framework;
using Unity.Netcode.TestHelpers.Runtime;
using UnityEngine;
using UnityEngine.TestTools;
namespace Unity.Netcode.RuntimeTests
{
public class OwnershipPermissionsTests : IntegrationTestWithApproximation
{
private GameObject m_PermissionsObject;
private StringBuilder m_ErrorLog = new StringBuilder();
protected override int NumberOfClients => 4;
public OwnershipPermissionsTests() : base(HostOrServer.DAHost)
{
}
protected override IEnumerator OnSetup()
{
m_ObjectToValidate = null;
OwnershipPermissionsTestHelper.CurrentOwnedInstance = null;
return base.OnSetup();
}
protected override void OnServerAndClientsCreated()
{
m_PermissionsObject = CreateNetworkObjectPrefab("PermObject");
m_PermissionsObject.AddComponent<OwnershipPermissionsTestHelper>();
base.OnServerAndClientsCreated();
}
private NetworkObject m_ObjectToValidate;
private bool ValidateObjectSpawnedOnAllClients()
{
m_ErrorLog.Clear();
var networkObjectId = m_ObjectToValidate.NetworkObjectId;
var name = m_ObjectToValidate.name;
if (!UseCMBService() && !m_ServerNetworkManager.SpawnManager.SpawnedObjects.ContainsKey(networkObjectId))
{
m_ErrorLog.Append($"Client-{m_ServerNetworkManager.LocalClientId} has not spawned {name}!");
return false;
}
foreach (var client in m_ClientNetworkManagers)
{
if (!client.SpawnManager.SpawnedObjects.ContainsKey(networkObjectId))
{
m_ErrorLog.Append($"Client-{client.LocalClientId} has not spawned {name}!");
return false;
}
}
return true;
}
private bool ValidatePermissionsOnAllClients()
{
var currentPermissions = (ushort)m_ObjectToValidate.Ownership;
var otherPermissions = (ushort)0;
var networkObjectId = m_ObjectToValidate.NetworkObjectId;
var objectName = m_ObjectToValidate.name;
m_ErrorLog.Clear();
if (!UseCMBService())
{
otherPermissions = (ushort)m_ServerNetworkManager.SpawnManager.SpawnedObjects[networkObjectId].Ownership;
if (currentPermissions != otherPermissions)
{
m_ErrorLog.Append($"Client-{m_ServerNetworkManager.LocalClientId} permissions for {objectName} is {otherPermissions} when it should be {currentPermissions}!");
return false;
}
}
foreach (var client in m_ClientNetworkManagers)
{
otherPermissions = (ushort)client.SpawnManager.SpawnedObjects[networkObjectId].Ownership;
if (currentPermissions != otherPermissions)
{
m_ErrorLog.Append($"Client-{client.LocalClientId} permissions for {objectName} is {otherPermissions} when it should be {currentPermissions}!");
return false;
}
}
return true;
}
private bool ValidateAllInstancesAreOwnedByClient(ulong clientId)
{
var networkObjectId = m_ObjectToValidate.NetworkObjectId;
var otherNetworkObject = (NetworkObject)null;
m_ErrorLog.Clear();
if (!UseCMBService())
{
otherNetworkObject = m_ServerNetworkManager.SpawnManager.SpawnedObjects[networkObjectId];
if (otherNetworkObject.OwnerClientId != clientId)
{
m_ErrorLog.Append($"[Client-{m_ServerNetworkManager.LocalClientId}][{otherNetworkObject.name}] Expected owner to be {clientId} but it was {otherNetworkObject.OwnerClientId}!");
return false;
}
}
foreach (var client in m_ClientNetworkManagers)
{
otherNetworkObject = client.SpawnManager.SpawnedObjects[networkObjectId];
if (otherNetworkObject.OwnerClientId != clientId)
{
m_ErrorLog.Append($"[Client-{client.LocalClientId}][{otherNetworkObject.name}] Expected owner to be {clientId} but it was {otherNetworkObject.OwnerClientId}!");
return false;
}
}
return true;
}
[UnityTest]
public IEnumerator ValidateOwnershipPermissionsTest()
{
var firstInstance = SpawnObject(m_PermissionsObject, m_ClientNetworkManagers[0]).GetComponent<NetworkObject>();
OwnershipPermissionsTestHelper.CurrentOwnedInstance = firstInstance;
var firstInstanceHelper = firstInstance.GetComponent<OwnershipPermissionsTestHelper>();
var networkObjectId = firstInstance.NetworkObjectId;
m_ObjectToValidate = OwnershipPermissionsTestHelper.CurrentOwnedInstance;
yield return WaitForConditionOrTimeOut(ValidateObjectSpawnedOnAllClients);
AssertOnTimeout($"[Failed To Spawn] {firstInstance.name}: \n {m_ErrorLog}");
// Validate the base non-assigned persmissions value for all instances are the same.
yield return WaitForConditionOrTimeOut(ValidatePermissionsOnAllClients);
AssertOnTimeout($"[Permissions Mismatch] {firstInstance.name}: \n {m_ErrorLog}");
//////////////////////////////////////
// Setting & Removing Ownership Flags:
//////////////////////////////////////
// Now, cycle through all permissions and validate that when the owner changes them the change
// is synchronized on all non-owner clients.
foreach (var permissionObject in Enum.GetValues(typeof(NetworkObject.OwnershipStatus)))
{
var permission = (NetworkObject.OwnershipStatus)permissionObject;
// Add the status
firstInstance.SetOwnershipStatus(permission);
// Validate the persmissions value for all instances are the same.
yield return WaitForConditionOrTimeOut(ValidatePermissionsOnAllClients);
AssertOnTimeout($"[Add][Permissions Mismatch] {firstInstance.name}: \n {m_ErrorLog}");
// Remove the status unless it is None (ignore None).
if (permission == NetworkObject.OwnershipStatus.None)
{
continue;
}
firstInstance.RemoveOwnershipStatus(permission);
// Validate the persmissions value for all instances are the same.
yield return WaitForConditionOrTimeOut(ValidatePermissionsOnAllClients);
AssertOnTimeout($"[Remove][Permissions Mismatch] {firstInstance.name}: \n {m_ErrorLog}");
}
//Add multiple flags at the same time
var multipleFlags = NetworkObject.OwnershipStatus.Transferable | NetworkObject.OwnershipStatus.Distributable | NetworkObject.OwnershipStatus.RequestRequired;
firstInstance.SetOwnershipStatus(multipleFlags, true);
Assert.IsTrue(firstInstance.HasOwnershipStatus(multipleFlags), $"[Set][Multi-flag Failure] Expected: {(ushort)multipleFlags} but was {(ushort)firstInstance.Ownership}!");
// Validate the persmissions value for all instances are the same.
yield return WaitForConditionOrTimeOut(ValidatePermissionsOnAllClients);
AssertOnTimeout($"[Set Multiple][Permissions Mismatch] {firstInstance.name}: \n {m_ErrorLog}");
// Remove multiple flags at the same time
multipleFlags = NetworkObject.OwnershipStatus.Transferable | NetworkObject.OwnershipStatus.RequestRequired;
firstInstance.RemoveOwnershipStatus(multipleFlags);
// Validate the two flags no longer are set
Assert.IsFalse(firstInstance.HasOwnershipStatus(multipleFlags), $"[Remove][Multi-flag Failure] Expected: {(ushort)NetworkObject.OwnershipStatus.Distributable} but was {(ushort)firstInstance.Ownership}!");
// Validate that the Distributable flag is still set
Assert.IsTrue(firstInstance.HasOwnershipStatus(NetworkObject.OwnershipStatus.Distributable), $"[Remove][Multi-flag Failure] Expected: {(ushort)NetworkObject.OwnershipStatus.Distributable} but was {(ushort)firstInstance.Ownership}!");
// Validate the persmissions value for all instances are the same.
yield return WaitForConditionOrTimeOut(ValidatePermissionsOnAllClients);
AssertOnTimeout($"[Set Multiple][Permissions Mismatch] {firstInstance.name}: \n {m_ErrorLog}");
//////////////////////
// Changing Ownership:
//////////////////////
// Clear the flags, set the permissions to transferrable, and lock ownership in one pass.
firstInstance.SetOwnershipStatus(NetworkObject.OwnershipStatus.Transferable, true, NetworkObject.OwnershipLockActions.SetAndLock);
// Validate the persmissions value for all instances are the same.
yield return WaitForConditionOrTimeOut(ValidatePermissionsOnAllClients);
AssertOnTimeout($"[Reset][Permissions Mismatch] {firstInstance.name}: \n {m_ErrorLog}");
var secondInstance = m_ClientNetworkManagers[1].SpawnManager.SpawnedObjects[networkObjectId];
var secondInstanceHelper = secondInstance.GetComponent<OwnershipPermissionsTestHelper>();
secondInstance.ChangeOwnership(m_ClientNetworkManagers[1].LocalClientId);
Assert.IsTrue(secondInstanceHelper.OwnershipPermissionsFailureStatus == NetworkObject.OwnershipPermissionsFailureStatus.Locked,
$"Expected {secondInstance.name} to return {NetworkObject.OwnershipPermissionsFailureStatus.Locked} but its permission failure" +
$" status is {secondInstanceHelper.OwnershipPermissionsFailureStatus}!");
firstInstance.SetOwnershipLock(false);
// Validate the persmissions value for all instances are the same.
yield return WaitForConditionOrTimeOut(ValidatePermissionsOnAllClients);
AssertOnTimeout($"[Unlock][Permissions Mismatch] {firstInstance.name}: \n {m_ErrorLog}");
// Sanity check to assure this client's instance isn't already the owner.
Assert.True(!secondInstance.IsOwner, $"[Ownership Check] Client-{m_ClientNetworkManagers[1].LocalClientId} already is the owner!");
// Now try to acquire ownership
secondInstance.ChangeOwnership(m_ClientNetworkManagers[1].LocalClientId);
// Validate the persmissions value for all instances are the same
yield return WaitForConditionOrTimeOut(() => secondInstance.IsOwner);
AssertOnTimeout($"[Acquire Ownership Failed] Client-{m_ClientNetworkManagers[1].LocalClientId} failed to get ownership!");
m_ObjectToValidate = OwnershipPermissionsTestHelper.CurrentOwnedInstance;
// Validate all other client instances are showing the same owner
yield return WaitForConditionOrTimeOut(() => ValidateAllInstancesAreOwnedByClient(m_ClientNetworkManagers[1].LocalClientId));
AssertOnTimeout($"[Ownership Mismatch] {secondInstance.name}: \n {m_ErrorLog}");
// Clear the flags, set the permissions to RequestRequired, and lock ownership in one pass.
secondInstance.SetOwnershipStatus(NetworkObject.OwnershipStatus.RequestRequired, true);
// Validate the persmissions value for all instances are the same.
yield return WaitForConditionOrTimeOut(ValidatePermissionsOnAllClients);
AssertOnTimeout($"[Unlock][Permissions Mismatch] {secondInstance.name}: \n {m_ErrorLog}");
// Attempt to acquire ownership by just changing it
firstInstance.ChangeOwnership(firstInstance.NetworkManager.LocalClientId);
// Assure we are denied ownership due to it requiring ownership be requested
Assert.IsTrue(firstInstanceHelper.OwnershipPermissionsFailureStatus == NetworkObject.OwnershipPermissionsFailureStatus.RequestRequired,
$"Expected {secondInstance.name} to return {NetworkObject.OwnershipPermissionsFailureStatus.RequestRequired} but its permission failure" +
$" status is {secondInstanceHelper.OwnershipPermissionsFailureStatus}!");
//////////////////////////////////
// Test for single race condition:
//////////////////////////////////
// Start with a request for the client we expect to be given ownership
var requestStatus = firstInstance.RequestOwnership();
Assert.True(requestStatus == NetworkObject.OwnershipRequestStatus.RequestSent, $"Client-{firstInstance.NetworkManager.LocalClientId} was unabled to send a request for ownership because: {requestStatus}!");
// Get the 3rd client to send a request at the "relatively" same time
var thirdInstance = m_ClientNetworkManagers[2].SpawnManager.SpawnedObjects[networkObjectId];
var thirdInstanceHelper = thirdInstance.GetComponent<OwnershipPermissionsTestHelper>();
// At the same time send a request by the third client.
requestStatus = thirdInstance.RequestOwnership();
// We expect the 3rd client's request should be able to be sent at this time as well (i.e. creates the race condition between two clients)
Assert.True(requestStatus == NetworkObject.OwnershipRequestStatus.RequestSent, $"Client-{m_ServerNetworkManager.LocalClientId} was unabled to send a request for ownership because: {requestStatus}!");
// We expect the first requesting client to be given ownership
yield return WaitForConditionOrTimeOut(() => firstInstance.IsOwner);
AssertOnTimeout($"[Acquire Ownership Failed] Client-{firstInstance.NetworkManager.LocalClientId} failed to get ownership! ({firstInstanceHelper.OwnershipRequestResponseStatus})(Owner: {OwnershipPermissionsTestHelper.CurrentOwnedInstance.OwnerClientId}");
m_ObjectToValidate = OwnershipPermissionsTestHelper.CurrentOwnedInstance;
// Just do a sanity check to assure ownership has changed on all clients.
yield return WaitForConditionOrTimeOut(() => ValidateAllInstancesAreOwnedByClient(firstInstance.NetworkManager.LocalClientId));
AssertOnTimeout($"[Ownership Mismatch] {firstInstance.name}: \n {m_ErrorLog}");
// Now, the third client should get a RequestInProgress returned as their request response
yield return WaitForConditionOrTimeOut(() => thirdInstanceHelper.OwnershipRequestResponseStatus == NetworkObject.OwnershipRequestResponseStatus.RequestInProgress);
AssertOnTimeout($"[Request In Progress Failed] Client-{thirdInstanceHelper.NetworkManager.LocalClientId} did not get the right request denied reponse!");
// Validate the persmissions value for all instances are the same.
yield return WaitForConditionOrTimeOut(ValidatePermissionsOnAllClients);
AssertOnTimeout($"[Unlock][Permissions Mismatch] {firstInstance.name}: \n {m_ErrorLog}");
///////////////////////////////////////////////
// Test for multiple ownership race conditions:
///////////////////////////////////////////////
// Get the 4th client's instance
var fourthInstance = m_ClientNetworkManagers[3].SpawnManager.SpawnedObjects[networkObjectId];
var fourthInstanceHelper = fourthInstance.GetComponent<OwnershipPermissionsTestHelper>();
// Send out a request from three clients at the same time
// The first one sent (and received for this test) gets ownership
requestStatus = secondInstance.RequestOwnership();
Assert.True(requestStatus == NetworkObject.OwnershipRequestStatus.RequestSent, $"Client-{secondInstance.NetworkManager.LocalClientId} was unabled to send a request for ownership because: {requestStatus}!");
requestStatus = thirdInstance.RequestOwnership();
Assert.True(requestStatus == NetworkObject.OwnershipRequestStatus.RequestSent, $"Client-{thirdInstance.NetworkManager.LocalClientId} was unabled to send a request for ownership because: {requestStatus}!");
requestStatus = fourthInstance.RequestOwnership();
Assert.True(requestStatus == NetworkObject.OwnershipRequestStatus.RequestSent, $"Client-{fourthInstance.NetworkManager.LocalClientId} was unabled to send a request for ownership because: {requestStatus}!");
// The 2nd and 3rd client should be denied and the 4th client should be approved
yield return WaitForConditionOrTimeOut(() =>
(fourthInstanceHelper.OwnershipRequestResponseStatus == NetworkObject.OwnershipRequestResponseStatus.RequestInProgress) &&
(thirdInstanceHelper.OwnershipRequestResponseStatus == NetworkObject.OwnershipRequestResponseStatus.RequestInProgress) &&
(secondInstanceHelper.OwnershipRequestResponseStatus == NetworkObject.OwnershipRequestResponseStatus.Approved)
);
AssertOnTimeout($"[Targeted Owner] Client-{secondInstanceHelper.NetworkManager.LocalClientId} did not get the right request denied reponse: {secondInstanceHelper.OwnershipRequestResponseStatus}!");
m_ObjectToValidate = OwnershipPermissionsTestHelper.CurrentOwnedInstance;
// Just do a sanity check to assure ownership has changed on all clients.
yield return WaitForConditionOrTimeOut(() => ValidateAllInstancesAreOwnedByClient(secondInstance.NetworkManager.LocalClientId));
AssertOnTimeout($"[Ownership Mismatch] {secondInstance.name}: \n {m_ErrorLog}");
// Validate the persmissions value for all instances are the same.
yield return WaitForConditionOrTimeOut(ValidatePermissionsOnAllClients);
AssertOnTimeout($"[Unlock][Permissions Mismatch] {secondInstance.name}: \n {m_ErrorLog}");
///////////////////////////////////////////////
// Test for targeted ownership request:
///////////////////////////////////////////////
// Now get the DAHost's client's instance
var daHostInstance = m_ServerNetworkManager.SpawnManager.SpawnedObjects[networkObjectId];
var daHostInstanceHelper = daHostInstance.GetComponent<OwnershipPermissionsTestHelper>();
secondInstanceHelper.AllowOwnershipRequest = true;
secondInstanceHelper.OnlyAllowTargetClientId = true;
secondInstanceHelper.ClientToAllowOwnership = daHostInstance.NetworkManager.LocalClientId;
// Send out a request from all three clients
requestStatus = firstInstance.RequestOwnership();
Assert.True(requestStatus == NetworkObject.OwnershipRequestStatus.RequestSent, $"Client-{firstInstance.NetworkManager.LocalClientId} was unabled to send a request for ownership because: {requestStatus}!");
requestStatus = thirdInstance.RequestOwnership();
Assert.True(requestStatus == NetworkObject.OwnershipRequestStatus.RequestSent, $"Client-{thirdInstance.NetworkManager.LocalClientId} was unabled to send a request for ownership because: {requestStatus}!");
requestStatus = fourthInstance.RequestOwnership();
Assert.True(requestStatus == NetworkObject.OwnershipRequestStatus.RequestSent, $"Client-{fourthInstance.NetworkManager.LocalClientId} was unabled to send a request for ownership because: {requestStatus}!");
requestStatus = daHostInstance.RequestOwnership();
Assert.True(requestStatus == NetworkObject.OwnershipRequestStatus.RequestSent, $"Client-{daHostInstance.NetworkManager.LocalClientId} was unabled to send a request for ownership because: {requestStatus}!");
// The server and the 2nd client should be denied and the third client should be approved
yield return WaitForConditionOrTimeOut(() =>
(firstInstanceHelper.OwnershipRequestResponseStatus == NetworkObject.OwnershipRequestResponseStatus.Denied) &&
(thirdInstanceHelper.OwnershipRequestResponseStatus == NetworkObject.OwnershipRequestResponseStatus.Denied) &&
(fourthInstanceHelper.OwnershipRequestResponseStatus == NetworkObject.OwnershipRequestResponseStatus.Denied) &&
(daHostInstanceHelper.OwnershipRequestResponseStatus == NetworkObject.OwnershipRequestResponseStatus.Approved)
);
AssertOnTimeout($"[Targeted Owner] Client-{daHostInstance.NetworkManager.LocalClientId} did not get the right request reponse: {daHostInstanceHelper.OwnershipRequestResponseStatus} Expecting: {NetworkObject.OwnershipRequestResponseStatus.Approved}!");
}
public class OwnershipPermissionsTestHelper : NetworkBehaviour
{
public static NetworkObject CurrentOwnedInstance;
public static Dictionary<ulong, Dictionary<ulong, List<NetworkObject>>> DistributedObjects = new Dictionary<ulong, Dictionary<ulong, List<NetworkObject>>>();
public bool AllowOwnershipRequest = true;
public bool OnlyAllowTargetClientId = false;
public ulong ClientToAllowOwnership;
public NetworkObject.OwnershipRequestResponseStatus OwnershipRequestResponseStatus { get; private set; }
public NetworkObject.OwnershipPermissionsFailureStatus OwnershipPermissionsFailureStatus { get; private set; }
public NetworkObject.OwnershipRequestResponseStatus ExpectOwnershipRequestResponseStatus { get; set; }
public override void OnNetworkSpawn()
{
NetworkObject.OnOwnershipRequested = OnOwnershipRequested;
NetworkObject.OnOwnershipRequestResponse = OnOwnershipRequestResponse;
NetworkObject.OnOwnershipPermissionsFailure = OnOwnershipPermissionsFailure;
base.OnNetworkSpawn();
}
private bool OnOwnershipRequested(ulong clientId)
{
// If we are not allowing any client to request (without locking), then deny all requests
if (!AllowOwnershipRequest)
{
return false;
}
// If we are only allowing a specific client and the requesting client is not the target,
// then deny the request
if (OnlyAllowTargetClientId && clientId != ClientToAllowOwnership)
{
return false;
}
// Otherwise, approve the request
return true;
}
private void OnOwnershipRequestResponse(NetworkObject.OwnershipRequestResponseStatus ownershipRequestResponseStatus)
{
OwnershipRequestResponseStatus = ownershipRequestResponseStatus;
}
private void OnOwnershipPermissionsFailure(NetworkObject.OwnershipPermissionsFailureStatus ownershipPermissionsFailureStatus)
{
OwnershipPermissionsFailureStatus = ownershipPermissionsFailureStatus;
}
public override void OnNetworkDespawn()
{
NetworkObject.OnOwnershipRequested = null;
NetworkObject.OnOwnershipRequestResponse = null;
base.OnNetworkSpawn();
}
protected override void OnOwnershipChanged(ulong previous, ulong current)
{
if (current == NetworkManager.LocalClientId)
{
CurrentOwnedInstance = NetworkObject;
}
base.OnOwnershipChanged(previous, current);
}
}
}
}

11
Tests/Runtime/DistributedAuthority/OwnershipPermissionsTests.cs.meta Normal file
View File

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

Some files were not shown because too many files have changed in this diff Show More