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

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

@@ -13,16 +13,21 @@ namespace Unity.Netcode.RuntimeTests
/// - Server destroy spawned => Object gets destroyed and despawned/destroyed on all clients. Server does not run <see cref="NetworkPrefaInstanceHandler.HandleNetworkPrefabDestroy"/>. Client runs it.
/// - Client destroy spawned => throw exception.
/// </summary>
[TestFixture(SessionModeTypes.DistributedAuthority)]
[TestFixture(SessionModeTypes.ClientServer)]
public class NetworkObjectDestroyTests : NetcodeIntegrationTest
{
protected override int NumberOfClients => 1;
protected override int NumberOfClients => 2;
public NetworkObjectDestroyTests(SessionModeTypes sessionModeType) : base(sessionModeType) { }
/// <summary>
/// Tests that a server can destroy a NetworkObject and that it gets despawned correctly.
/// </summary>
/// <returns></returns>
[UnityTest]
public IEnumerator TestNetworkObjectServerDestroy()
public IEnumerator TestNetworkObjectAuthorityDestroy()
{
// This is the *SERVER VERSION* of the *CLIENT PLAYER*
var serverClientPlayerResult = new NetcodeIntegrationTestHelpers.ResultWrapper<NetworkObject>();
@@ -35,15 +40,25 @@ namespace Unity.Netcode.RuntimeTests
Assert.IsNotNull(serverClientPlayerResult.Result.gameObject);
Assert.IsNotNull(clientClientPlayerResult.Result.gameObject);
// destroy the server player
Object.Destroy(serverClientPlayerResult.Result.gameObject);
var targetNetworkManager = m_ClientNetworkManagers[0];
if (m_DistributedAuthority)
{
targetNetworkManager = m_ClientNetworkManagers[1];
// destroy the authoritative player (distributed authority)
Object.Destroy(clientClientPlayerResult.Result.gameObject);
}
else
{
// destroy the authoritative player (client-server)
Object.Destroy(serverClientPlayerResult.Result.gameObject);
}
yield return NetcodeIntegrationTestHelpers.WaitForMessageOfTypeHandled<DestroyObjectMessage>(m_ClientNetworkManagers[0]);
yield return NetcodeIntegrationTestHelpers.WaitForMessageOfTypeHandled<DestroyObjectMessage>(targetNetworkManager);
Assert.IsTrue(serverClientPlayerResult.Result == null); // Assert.IsNull doesn't work here
Assert.IsTrue(clientClientPlayerResult.Result == null);
// create an unspawned networkobject and destroy it
// validate that any unspawned networkobject can be destroyed
var go = new GameObject();
go.AddComponent<NetworkObject>();
Object.Destroy(go);
@@ -74,16 +89,42 @@ namespace Unity.Netcode.RuntimeTests
//destroying a NetworkObject while shutting down is allowed
if (isShuttingDown)
{
m_ClientNetworkManagers[0].Shutdown();
if (m_DistributedAuthority)
{
// Shutdown the 2nd client
m_ClientNetworkManagers[1].Shutdown();
}
else
{
// Shutdown the
m_ClientNetworkManagers[0].Shutdown();
}
}
else
{
LogAssert.ignoreFailingMessages = true;
NetworkLog.NetworkManagerOverride = m_ClientNetworkManagers[0];
}
m_ClientPlayerName = clientPlayer.gameObject.name;
m_ClientNetworkObjectId = clientPlayer.NetworkObjectId;
Object.DestroyImmediate(clientPlayer.gameObject);
if (m_DistributedAuthority)
{
m_ClientPlayerName = m_PlayerNetworkObjects[m_ClientNetworkManagers[1].LocalClientId][m_ClientNetworkManagers[0].LocalClientId].gameObject.name;
m_ClientNetworkObjectId = m_PlayerNetworkObjects[m_ClientNetworkManagers[1].LocalClientId][m_ClientNetworkManagers[0].LocalClientId].NetworkObjectId;
if (!isShuttingDown)
{
NetworkLog.NetworkManagerOverride = m_ClientNetworkManagers[1];
}
// the 2nd client attempts to destroy the 1st client's player object (if shutting down then "ok" if not then not "ok")
Object.DestroyImmediate(m_PlayerNetworkObjects[m_ClientNetworkManagers[1].LocalClientId][m_ClientNetworkManagers[0].LocalClientId].gameObject);
}
else
{
// the 1st client attempts to destroy its own player object (if shutting down then "ok" if not then not "ok")
Object.DestroyImmediate(m_ClientNetworkManagers[0].LocalClient.PlayerObject.gameObject);
}
// destroying a NetworkObject while a session is active is not allowed
if (!isShuttingDown)
@@ -95,16 +136,25 @@ namespace Unity.Netcode.RuntimeTests
private bool HaveLogsBeenReceived()
{
if (!NetcodeLogAssert.HasLogBeenReceived(LogType.Error, $"[Netcode] [Invalid Destroy][{m_ClientPlayerName}][NetworkObjectId:{m_ClientNetworkObjectId}] Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call Destroy or Despawn on the server/host instead."))
if (m_DistributedAuthority)
{
return false;
if (!NetcodeLogAssert.HasLogBeenReceived(LogType.Error, $"[Netcode] [Invalid Destroy][{m_ClientPlayerName}][NetworkObjectId:{m_ClientNetworkObjectId}] Destroy a spawned {nameof(NetworkObject)} on a non-owner client is not valid during a distributed authority session. Call Destroy or Despawn on the client-owner instead."))
{
return false;
}
}
if (!NetcodeLogAssert.HasLogBeenReceived(LogType.Error, $"[Netcode-Server Sender={m_ClientNetworkManagers[0].LocalClientId}] [Invalid Destroy][{m_ClientPlayerName}][NetworkObjectId:{m_ClientNetworkObjectId}] Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call Destroy or Despawn on the server/host instead."))
else
{
return false;
}
if (!NetcodeLogAssert.HasLogBeenReceived(LogType.Error, $"[Netcode] [Invalid Destroy][{m_ClientPlayerName}][NetworkObjectId:{m_ClientNetworkObjectId}] Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call Destroy or Despawn on the server/host instead."))
{
return false;
}
if (!NetcodeLogAssert.HasLogBeenReceived(LogType.Error, $"[Netcode-Server Sender={m_ClientNetworkManagers[0].LocalClientId}] [Invalid Destroy][{m_ClientPlayerName}][NetworkObjectId:{m_ClientNetworkObjectId}] Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call Destroy or Despawn on the server/host instead."))
{
return false;
}
}
return true;
}

17
Tests/Runtime/NetworkObject/NetworkObjectDontDestroyWithOwnerTests.cs
View File

@@ -8,6 +8,7 @@ using UnityEngine.TestTools;
namespace Unity.Netcode.RuntimeTests
{
[TestFixture(HostOrServer.DAHost)]
[TestFixture(HostOrServer.Host)]
[TestFixture(HostOrServer.Server)]
public class NetworkObjectDontDestroyWithOwnerTests : NetcodeIntegrationTest
@@ -36,6 +37,22 @@ namespace Unity.Netcode.RuntimeTests
yield return WaitForConditionOrTimeOut(() => client.SpawnManager.GetClientOwnedObjects(clientId).Count() == k_NumberObjectsToSpawn + 1);
Assert.False(s_GlobalTimeoutHelper.TimedOut, $"Timed out waiting for client to have 33 NetworkObjects spawned! Only {client.SpawnManager.GetClientOwnedObjects(clientId).Count()} were assigned!");
// Since clients spawn their objects locally in distributed authority mode, we have to rebuild the list of the client
// owned objects on the (DAHost) server-side because when the client disconnects it will destroy its local instances.
if (m_DistributedAuthority)
{
networkObjects.Clear();
var serversideClientOwnedObjects = m_ServerNetworkManager.SpawnManager.GetClientOwnedObjects(clientId);
foreach (var networkObject in serversideClientOwnedObjects)
{
if (!networkObject.IsPlayerObject)
{
networkObjects.Add(networkObject.gameObject);
}
}
}
// disconnect the client that owns all the clients
NetcodeIntegrationTestHelpers.StopOneClient(client);

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

@@ -10,12 +10,13 @@ namespace Unity.Netcode.RuntimeTests
/// <summary>
/// Tests that check OnNetworkDespawn being invoked
/// </summary>
[TestFixture(HostOrServer.DAHost)]
[TestFixture(HostOrServer.Host)]
[TestFixture(HostOrServer.Server)]
public class NetworkObjectOnNetworkDespawnTests : NetcodeIntegrationTest
{
private const string k_ObjectName = "TestDespawn";
public enum InstanceType
public enum InstanceTypes
{
Server,
Client
@@ -23,7 +24,10 @@ namespace Unity.Netcode.RuntimeTests
protected override int NumberOfClients => 1;
private GameObject m_ObjectToSpawn;
private NetworkObject m_NetworkObject;
private HostOrServer m_HostOrServer;
public NetworkObjectOnNetworkDespawnTests(HostOrServer hostOrServer) : base(hostOrServer)
{
m_HostOrServer = hostOrServer;
@@ -31,32 +35,17 @@ namespace Unity.Netcode.RuntimeTests
internal class OnNetworkDespawnTestComponent : NetworkBehaviour
{
public static bool OnServerNetworkDespawnCalled { get; internal set; }
public static bool OnClientNetworkDespawnCalled { get; internal set; }
public bool OnNetworkDespawnCalled { get; internal set; }
public override void OnNetworkSpawn()
{
if (IsServer)
{
OnServerNetworkDespawnCalled = false;
}
else
{
OnClientNetworkDespawnCalled = false;
}
OnNetworkDespawnCalled = false;
base.OnNetworkSpawn();
}
public override void OnNetworkDespawn()
{
if (IsServer)
{
OnServerNetworkDespawnCalled = true;
}
else
{
OnClientNetworkDespawnCalled = true;
}
OnNetworkDespawnCalled = true;
base.OnNetworkDespawn();
}
}
@@ -68,46 +57,67 @@ namespace Unity.Netcode.RuntimeTests
base.OnServerAndClientsCreated();
}
private bool ObjectSpawnedOnAllNetworkManagerInstances()
{
if (!s_GlobalNetworkObjects.ContainsKey(m_ServerNetworkManager.LocalClientId))
{
return false;
}
if (!s_GlobalNetworkObjects[m_ServerNetworkManager.LocalClientId].ContainsKey(m_NetworkObject.NetworkObjectId))
{
return false;
}
foreach (var clientNetworkManager in m_ClientNetworkManagers)
{
if (!s_GlobalNetworkObjects.ContainsKey(clientNetworkManager.LocalClientId))
{
return false;
}
if (!s_GlobalNetworkObjects[clientNetworkManager.LocalClientId].ContainsKey(m_NetworkObject.NetworkObjectId))
{
return false;
}
}
return true;
}
/// <summary>
/// This test validates that <see cref="NetworkBehaviour.OnNetworkDespawn"/> is invoked when the
/// <see cref="NetworkManager"/> is shutdown.
/// </summary>
[UnityTest]
public IEnumerator TestNetworkObjectDespawnOnShutdown()
public IEnumerator TestNetworkObjectDespawnOnShutdown([Values(InstanceTypes.Server, InstanceTypes.Client)] InstanceTypes despawnCheck)
{
// Spawn the test object
var spawnedObject = SpawnObject(m_ObjectToSpawn, m_ServerNetworkManager);
var spawnedNetworkObject = spawnedObject.GetComponent<NetworkObject>();
// Wait for the client to spawn the object
yield return WaitForConditionOrTimeOut(() =>
var networkManager = despawnCheck == InstanceTypes.Server ? m_ServerNetworkManager : m_ClientNetworkManagers[0];
var networkManagerOwner = m_ServerNetworkManager;
if (m_DistributedAuthority)
{
if (!s_GlobalNetworkObjects.ContainsKey(m_ClientNetworkManagers[0].LocalClientId))
{
return false;
}
if (!s_GlobalNetworkObjects[m_ClientNetworkManagers[0].LocalClientId].ContainsKey(spawnedNetworkObject.NetworkObjectId))
{
return false;
}
return true;
});
networkManagerOwner = networkManager;
}
AssertOnTimeout($"Timed out waiting for client to spawn {k_ObjectName}!");
// Spawn the test object
var spawnedObject = SpawnObject(m_ObjectToSpawn, networkManagerOwner);
m_NetworkObject = spawnedObject.GetComponent<NetworkObject>();
yield return WaitForConditionOrTimeOut(ObjectSpawnedOnAllNetworkManagerInstances);
AssertOnTimeout($"Timed out waiting for all {nameof(NetworkManager)} instances to spawn {m_NetworkObject.name}!");
// Get the spawned object relative to which NetworkManager instance we are testing.
var relativeSpawnedObject = s_GlobalNetworkObjects[networkManager.LocalClientId][m_NetworkObject.NetworkObjectId];
var onNetworkDespawnTestComponent = relativeSpawnedObject.GetComponent<OnNetworkDespawnTestComponent>();
// Confirm it is not set before shutting down the NetworkManager
Assert.IsFalse(OnNetworkDespawnTestComponent.OnClientNetworkDespawnCalled, "[Client-side] despawn state is already set (should not be set at this point)!");
Assert.IsFalse(OnNetworkDespawnTestComponent.OnServerNetworkDespawnCalled, $"[{m_HostOrServer}-side] despawn state is already set (should not be set at this point)!");
Assert.IsFalse(onNetworkDespawnTestComponent.OnNetworkDespawnCalled, $"{nameof(OnNetworkDespawnTestComponent.OnNetworkDespawnCalled)} was set prior to shutting down!");
// Shutdown the client-side first to validate the client-side instance invokes OnNetworkDespawn
m_ClientNetworkManagers[0].Shutdown();
yield return WaitForConditionOrTimeOut(() => OnNetworkDespawnTestComponent.OnClientNetworkDespawnCalled);
AssertOnTimeout($"[Client-side] Timed out waiting for {k_ObjectName}'s {nameof(NetworkBehaviour.OnNetworkDespawn)} to be invoked!");
// Shutdown the NetworkManager instance we are testing.
networkManager.Shutdown();
// Shutdown the servr-host-side second to validate servr-host-side instance invokes OnNetworkDespawn
m_ServerNetworkManager.Shutdown();
yield return WaitForConditionOrTimeOut(() => OnNetworkDespawnTestComponent.OnClientNetworkDespawnCalled);
AssertOnTimeout($"[{m_HostOrServer}-side]Timed out waiting for {k_ObjectName}'s {nameof(NetworkBehaviour.OnNetworkDespawn)} to be invoked!");
// Confirm that OnNetworkDespawn is invoked after shutdown
yield return WaitForConditionOrTimeOut(() => onNetworkDespawnTestComponent.OnNetworkDespawnCalled);
AssertOnTimeout($"Timed out waiting for {nameof(NetworkObject)} instance to despawn on the {despawnCheck} side!");
}
}
}

44
Tests/Runtime/NetworkObject/NetworkObjectOnSpawnTests.cs
View File

@@ -7,6 +7,8 @@ using UnityEngine.TestTools;
namespace Unity.Netcode.RuntimeTests
{
[TestFixture(SessionModeTypes.DistributedAuthority)]
[TestFixture(SessionModeTypes.ClientServer)]
public class NetworkObjectOnSpawnTests : NetcodeIntegrationTest
{
private GameObject m_TestNetworkObjectPrefab;
@@ -27,23 +29,39 @@ namespace Unity.Netcode.RuntimeTests
private const string k_WithObserversError = "Not all clients spawned the";
private const string k_WithoutObserversError = "A client spawned the";
public NetworkObjectOnSpawnTests(SessionModeTypes sessionModeType) : base(sessionModeType) { }
protected override void OnServerAndClientsCreated()
{
m_ObserverPrefab = CreateNetworkObjectPrefab(k_ObserverTestObjName);
base.OnServerAndClientsCreated();
}
private bool CheckClientsSideObserverTestObj()
{
foreach (var client in m_ClientNetworkManagers)
{
if (!s_GlobalNetworkObjects.ContainsKey(client.LocalClientId))
if (m_ObserverTestType == ObserverTestTypes.WithObservers)
{
// When no observers there shouldn't be any client spawned NetworkObjects
// (players are held in a different list)
return !(m_ObserverTestType == ObserverTestTypes.WithObservers);
// When validating this portion of the test and spawning with observers is true, there
// should be spawned objects on the clients.
if (!s_GlobalNetworkObjects.ContainsKey(client.LocalClientId))
{
return false;
}
}
else
{
// When validating this portion of the test and spawning with observers is false, there
// should be no spawned objects on the clients.
if (s_GlobalNetworkObjects.ContainsKey(client.LocalClientId))
{
return false;
}
// We don't need to check anything else for spawn without observers
continue;
}
var clientObjects = s_GlobalNetworkObjects[client.LocalClientId];
// Make sure they did spawn the object
if (m_ObserverTestType == ObserverTestTypes.WithObservers)
@@ -83,10 +101,16 @@ namespace Unity.Netcode.RuntimeTests
/// </summary>
/// <param name="observerTestTypes">whether to spawn with or without observers</param>
[UnityTest]
public IEnumerator ObserverSpawnTests([Values] ObserverTestTypes observerTestTypes, [Values] bool sceneManagement)
public IEnumerator ObserverSpawnTests([Values] ObserverTestTypes observerTestTypes, [Values] SceneManagementState sceneManagement)
{
if (!sceneManagement)
if (sceneManagement == SceneManagementState.SceneManagementDisabled)
{
// When scene management is disabled, we need this wait period for all clients to be up to date with
// all other clients before beginning the process of stopping all clients.
if (m_DistributedAuthority)
{
yield return new WaitForSeconds(0.5f);
}
// Disable prefabs to prevent them from being destroyed
foreach (var networkPrefab in m_ServerNetworkManager.NetworkConfig.Prefabs.Prefabs)
{
@@ -156,8 +180,10 @@ namespace Unity.Netcode.RuntimeTests
m_ObserverTestType = ObserverTestTypes.WithoutObservers;
// Just give a little time to make sure nothing spawned
yield return s_DefaultWaitForTick;
yield return WaitForConditionOrTimeOut(CheckClientsSideObserverTestObj);
AssertOnTimeout($"{(withoutObservers ? k_WithoutObserversError : k_WithObserversError)} {k_ObserverTestObjName} object!");
// This just requires a targeted check to assure the newly joined client did not spawn the NetworkObject with SpawnWithObservers set to false
var lateJoinClientId = m_ClientNetworkManagers[m_ClientNetworkManagers.Length - 1].LocalClientId;
Assert.False(s_GlobalNetworkObjects.ContainsKey(lateJoinClientId), $"[Client-{lateJoinClientId}] Spawned {instance.name} when it shouldn't have!");
// Now validate that we can make the NetworkObject visible to the newly joined client
m_ObserverTestNetworkObject.NetworkShow(m_ClientNetworkManagers[NumberOfClients].LocalClientId);

205
Tests/Runtime/NetworkObject/NetworkObjectOwnershipPropertiesTests.cs Normal file
View File

@@ -0,0 +1,205 @@
using System.Collections;
using System.Linq;
using System.Text;
using NUnit.Framework;
using Unity.Netcode.TestHelpers.Runtime;
using UnityEngine;
using UnityEngine.TestTools;
namespace Unity.Netcode.RuntimeTests
{
[TestFixture(SessionModeTypes.DistributedAuthority)]
[TestFixture(SessionModeTypes.ClientServer)]
public class NetworkObjectOwnershipPropertiesTests : NetcodeIntegrationTest
{
private class DummyNetworkBehaviour : NetworkBehaviour
{
}
protected override int NumberOfClients => 2;
private GameObject m_PrefabToSpawn;
private NetworkObject m_OwnerSpawnedInstance;
private NetworkObject m_TargetOwnerInstance;
private NetworkManager m_InitialOwner;
private NetworkManager m_NextTargetOwner;
private ulong m_InitialOwnerId;
private ulong m_TargetOwnerId;
private bool m_SpawnedInstanceIsOwner;
private bool m_InitialOwnerOwnedBySever;
private bool m_TargetOwnerOwnedBySever;
public NetworkObjectOwnershipPropertiesTests(SessionModeTypes sessionModeType) : base(sessionModeType) { }
protected override IEnumerator OnTearDown()
{
m_OwnerSpawnedInstance = null;
m_InitialOwner = null;
m_NextTargetOwner = null;
m_PrefabToSpawn = null;
return base.OnTearDown();
}
protected override void OnServerAndClientsCreated()
{
m_PrefabToSpawn = CreateNetworkObjectPrefab("ClientOwnedObject");
m_PrefabToSpawn.gameObject.AddComponent<DummyNetworkBehaviour>();
m_PrefabToSpawn.GetComponent<NetworkObject>().SetOwnershipStatus(NetworkObject.OwnershipStatus.Distributable);
}
public enum InstanceTypes
{
Server,
Client
}
private StringBuilder m_OwnershipPropagatedFailures = new StringBuilder();
private bool OwnershipPropagated()
{
var conditionMet = true;
m_OwnershipPropagatedFailures.Clear();
// In distributed authority mode, we will check client owner to DAHost owner with InstanceTypes.Server and client owner to client
// when InstanceTypes.Client
if (m_DistributedAuthority)
{
if (!m_ClientNetworkManagers[1].SpawnManager.GetClientOwnedObjects(m_NextTargetOwner.LocalClientId).Any(x => x.NetworkObjectId == m_OwnerSpawnedInstance.NetworkObjectId))
{
conditionMet = false;
m_OwnershipPropagatedFailures.AppendLine($"Client-{m_ClientNetworkManagers[1].LocalClientId} has no ownership entry for {m_OwnerSpawnedInstance.name} ({m_OwnerSpawnedInstance.NetworkObjectId})");
}
if (!m_ClientNetworkManagers[0].SpawnManager.GetClientOwnedObjects(m_NextTargetOwner.LocalClientId).Any(x => x.NetworkObjectId == m_OwnerSpawnedInstance.NetworkObjectId))
{
conditionMet = false;
m_OwnershipPropagatedFailures.AppendLine($"Client-{m_ClientNetworkManagers[0].LocalClientId} has no ownership entry for {m_OwnerSpawnedInstance.name} ({m_OwnerSpawnedInstance.NetworkObjectId})");
}
if (!m_ServerNetworkManager.SpawnManager.GetClientOwnedObjects(m_NextTargetOwner.LocalClientId).Any(x => x.NetworkObjectId == m_OwnerSpawnedInstance.NetworkObjectId))
{
conditionMet = false;
m_OwnershipPropagatedFailures.AppendLine($"Client-{m_ServerNetworkManager.LocalClientId} has no ownership entry for {m_OwnerSpawnedInstance.name} ({m_OwnerSpawnedInstance.NetworkObjectId})");
}
}
else
{
if (m_NextTargetOwner != m_ServerNetworkManager)
{
if (!m_NextTargetOwner.SpawnManager.GetClientOwnedObjects(m_NextTargetOwner.LocalClientId).Any(x => x.NetworkObjectId == m_OwnerSpawnedInstance.NetworkObjectId))
{
conditionMet = false;
m_OwnershipPropagatedFailures.AppendLine($"Client-{m_NextTargetOwner.LocalClientId} has no ownership entry for {m_OwnerSpawnedInstance.name} ({m_OwnerSpawnedInstance.NetworkObjectId})");
}
}
if (!m_ServerNetworkManager.SpawnManager.GetClientOwnedObjects(m_NextTargetOwner.LocalClientId).Any(x => x.NetworkObjectId == m_OwnerSpawnedInstance.NetworkObjectId))
{
conditionMet = false;
m_OwnershipPropagatedFailures.AppendLine($"Client-{m_ServerNetworkManager.LocalClientId} has no ownership entry for {m_OwnerSpawnedInstance.name} ({m_OwnerSpawnedInstance.NetworkObjectId})");
}
}
return conditionMet;
}
private void ValidateOwnerShipProperties(bool targetIsOwner = false)
{
Assert.AreEqual(m_OwnerSpawnedInstance.IsOwner, m_SpawnedInstanceIsOwner);
Assert.AreEqual(m_OwnerSpawnedInstance.IsOwnedByServer, m_InitialOwnerOwnedBySever);
Assert.AreEqual(targetIsOwner ? m_TargetOwnerId : m_InitialOwnerId, m_OwnerSpawnedInstance.OwnerClientId);
var initialOwnerBehaviour = m_OwnerSpawnedInstance.GetComponent<DummyNetworkBehaviour>();
Assert.AreEqual(initialOwnerBehaviour.IsOwner, m_SpawnedInstanceIsOwner);
Assert.AreEqual(initialOwnerBehaviour.IsOwnedByServer, m_InitialOwnerOwnedBySever);
Assert.AreEqual(targetIsOwner ? m_TargetOwnerId : m_InitialOwnerId, initialOwnerBehaviour.OwnerClientId);
Assert.AreEqual(m_TargetOwnerInstance.IsOwner, targetIsOwner);
Assert.AreEqual(m_TargetOwnerInstance.IsOwnedByServer, m_TargetOwnerOwnedBySever);
Assert.AreEqual(targetIsOwner ? m_TargetOwnerId : m_InitialOwnerId, m_TargetOwnerInstance.OwnerClientId);
var targetOwnerBehaviour = m_TargetOwnerInstance.GetComponent<DummyNetworkBehaviour>();
Assert.AreEqual(targetOwnerBehaviour.IsOwner, targetIsOwner);
Assert.AreEqual(targetOwnerBehaviour.IsOwnedByServer, m_TargetOwnerOwnedBySever);
Assert.AreEqual(targetIsOwner ? m_TargetOwnerId : m_InitialOwnerId, m_TargetOwnerInstance.OwnerClientId);
}
[UnityTest]
public IEnumerator ValidatePropertiesWithOwnershipChanges([Values(InstanceTypes.Server, InstanceTypes.Client)] InstanceTypes instanceType)
{
m_NextTargetOwner = instanceType == InstanceTypes.Server ? m_ServerNetworkManager : m_ClientNetworkManagers[0];
m_InitialOwner = instanceType == InstanceTypes.Client ? m_ServerNetworkManager : m_ClientNetworkManagers[0];
// In distributed authority mode, we will check client owner to DAHost owner with InstanceTypes.Server and client owner to client
// when InstanceTypes.Client
if (m_DistributedAuthority)
{
m_InitialOwner = m_ClientNetworkManagers[0];
if (instanceType == InstanceTypes.Client)
{
m_NextTargetOwner = m_ClientNetworkManagers[1];
}
m_PrefabToSpawn.GetComponent<NetworkObject>().SetOwnershipStatus(NetworkObject.OwnershipStatus.Transferable);
}
m_InitialOwnerId = m_InitialOwner.LocalClientId;
m_TargetOwnerId = m_NextTargetOwner.LocalClientId;
m_InitialOwnerOwnedBySever = m_InitialOwner.IsServer;
m_TargetOwnerOwnedBySever = m_InitialOwner.IsServer;
var objectInstance = SpawnObject(m_PrefabToSpawn, m_InitialOwner);
m_OwnerSpawnedInstance = objectInstance.GetComponent<NetworkObject>();
m_SpawnedInstanceIsOwner = m_OwnerSpawnedInstance.NetworkManager == m_InitialOwner;
// Sanity check to verify that the next owner to target is not the owner of the spawned object
var hasEntry = m_InitialOwner.SpawnManager.GetClientOwnedObjects(m_NextTargetOwner.LocalClientId).Any(x => x.NetworkObjectId == m_OwnerSpawnedInstance.NetworkObjectId);
Assert.False(hasEntry);
// Since CreateObjectMessage gets proxied by DAHost, just wait until the next target owner has the spawned instance in the s_GlobalNetworkObjects table.
yield return WaitForConditionOrTimeOut(() => s_GlobalNetworkObjects.ContainsKey(m_NextTargetOwner.LocalClientId) && s_GlobalNetworkObjects[m_NextTargetOwner.LocalClientId].ContainsKey(m_OwnerSpawnedInstance.NetworkObjectId));
AssertOnTimeout($"Timed out waiting for Client-{m_NextTargetOwner.LocalClientId} to have an instance entry of {m_OwnerSpawnedInstance.name}-{m_OwnerSpawnedInstance.NetworkObjectId}!");
// Get the target client's instance of the spawned object
m_TargetOwnerInstance = s_GlobalNetworkObjects[m_NextTargetOwner.LocalClientId][m_OwnerSpawnedInstance.NetworkObjectId];
// Validate that NetworkObject and NetworkBehaviour ownership properties are correct
ValidateOwnerShipProperties();
// The authority always changes the ownership
// Client-Server: It will always be the host instance
// Distributed Authority: It can be either the DAHost or the client
if (m_DistributedAuthority)
{
// Use the target client's instance to change ownership
m_TargetOwnerInstance.ChangeOwnership(m_NextTargetOwner.LocalClientId);
if (instanceType == InstanceTypes.Client)
{
var networkManagersList = new System.Collections.Generic.List<NetworkManager>() { m_ServerNetworkManager, m_ClientNetworkManagers[0] };
// Provide enough time for the client to receive and process the spawned message.
yield return WaitForMessageReceived<ChangeOwnershipMessage>(networkManagersList);
}
else
{
// Provide enough time for the client to receive and process the change in ownership message.
yield return WaitForMessageReceived<ChangeOwnershipMessage>(m_ClientNetworkManagers.ToList());
}
}
else
{
m_OwnerSpawnedInstance.ChangeOwnership(m_NextTargetOwner.LocalClientId);
// Provide enough time for the client to receive and process the change in ownership message.
yield return WaitForMessageReceived<ChangeOwnershipMessage>(m_ClientNetworkManagers.ToList());
}
// Ensure it's the ownership tables are updated
yield return WaitForConditionOrTimeOut(OwnershipPropagated);
AssertOnTimeout($"Timed out waiting for ownership to propagate!\n{m_OwnershipPropagatedFailures}");
m_SpawnedInstanceIsOwner = m_OwnerSpawnedInstance.NetworkManager == m_NextTargetOwner;
if (m_SpawnedInstanceIsOwner)
{
m_InitialOwnerOwnedBySever = m_OwnerSpawnedInstance.NetworkManager.IsServer;
}
m_InitialOwnerOwnedBySever = m_NextTargetOwner.IsServer;
m_TargetOwnerOwnedBySever = m_NextTargetOwner.IsServer;
// Validate that NetworkObject and NetworkBehaviour ownership properties are correct
ValidateOwnerShipProperties(true);
}
}
}

11
Tests/Runtime/NetworkObject/NetworkObjectOwnershipPropertiesTests.cs.meta Normal file
View File

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

82
Tests/Runtime/NetworkObject/NetworkObjectOwnershipTests.cs
View File

@@ -10,6 +10,8 @@ namespace Unity.Netcode.RuntimeTests
{
public class NetworkObjectOwnershipComponent : NetworkBehaviour
{
public static Dictionary<ulong, NetworkObjectOwnershipComponent> SpawnedInstances = new Dictionary<ulong, NetworkObjectOwnershipComponent>();
public bool OnLostOwnershipFired = false;
public bool OnGainedOwnershipFired = false;
@@ -23,6 +25,15 @@ namespace Unity.Netcode.RuntimeTests
OnGainedOwnershipFired = true;
}
public override void OnNetworkSpawn()
{
if (!SpawnedInstances.ContainsKey(NetworkManager.LocalClientId))
{
SpawnedInstances.Add(NetworkManager.LocalClientId, this);
}
base.OnNetworkSpawn();
}
public void ResetFlags()
{
OnLostOwnershipFired = false;
@@ -30,6 +41,8 @@ namespace Unity.Netcode.RuntimeTests
}
}
[TestFixture(HostOrServer.DAHost)]
[TestFixture(HostOrServer.Host)]
[TestFixture(HostOrServer.Server)]
public class NetworkObjectOwnershipTests : NetcodeIntegrationTest
@@ -48,10 +61,20 @@ namespace Unity.Netcode.RuntimeTests
Remove
}
protected override IEnumerator OnSetup()
{
NetworkObjectOwnershipComponent.SpawnedInstances.Clear();
return base.OnSetup();
}
protected override void OnServerAndClientsCreated()
{
m_OwnershipPrefab = CreateNetworkObjectPrefab("OnwershipPrefab");
m_OwnershipPrefab.AddComponent<NetworkObjectOwnershipComponent>();
if (m_DistributedAuthority)
{
m_OwnershipPrefab.GetComponent<NetworkObject>().SetOwnershipStatus(NetworkObject.OwnershipStatus.Transferable);
}
base.OnServerAndClientsCreated();
}
@@ -67,6 +90,23 @@ namespace Unity.Netcode.RuntimeTests
Assert.NotNull(clientPlayerObject, $"Client Id {m_ClientNetworkManagers[0].LocalClientId} does not have its local player marked as an owned object using local client!");
}
private bool AllObjectsSpawnedOnClients()
{
if (!NetworkObjectOwnershipComponent.SpawnedInstances.ContainsKey(m_ServerNetworkManager.LocalClientId))
{
return false;
}
foreach (var client in m_ClientNetworkManagers)
{
if (!NetworkObjectOwnershipComponent.SpawnedInstances.ContainsKey(client.LocalClientId))
{
return false;
}
}
return true;
}
[UnityTest]
public IEnumerator TestOwnershipCallbacks([Values] OwnershipChecks ownershipChecks)
{
@@ -75,6 +115,9 @@ namespace Unity.Netcode.RuntimeTests
yield return NetcodeIntegrationTestHelpers.WaitForMessageOfTypeHandled<CreateObjectMessage>(m_ClientNetworkManagers[0]);
yield return WaitForConditionOrTimeOut(AllObjectsSpawnedOnClients);
AssertOnTimeout($"Timed out waiting for all clients to spawn the ownership object!");
var ownershipNetworkObjectId = m_OwnershipNetworkObject.NetworkObjectId;
Assert.That(ownershipNetworkObjectId, Is.GreaterThan(0));
Assert.That(m_ServerNetworkManager.SpawnManager.SpawnedObjects.ContainsKey(ownershipNetworkObjectId));
@@ -123,18 +166,22 @@ namespace Unity.Netcode.RuntimeTests
else
{
// Validates that when ownership is removed the server gets an OnGainedOwnership notification
serverObject.RemoveOwnership();
// In distributed authority mode, the current owner just rolls the ownership back over to the DAHost client (i.e. host mocking CMB Service)
if (m_DistributedAuthority)
{
clientObject.ChangeOwnership(NetworkManager.ServerClientId);
}
else
{
serverObject.RemoveOwnership();
}
}
yield return s_DefaultWaitForTick;
yield return WaitForConditionOrTimeOut(() => serverComponent.OnGainedOwnershipFired && serverComponent.OwnerClientId == m_ServerNetworkManager.LocalClientId);
AssertOnTimeout($"Timed out waiting for ownership to be transfered back to the host instance!");
Assert.That(serverComponent.OnGainedOwnershipFired);
Assert.That(serverComponent.OwnerClientId, Is.EqualTo(m_ServerNetworkManager.LocalClientId));
yield return WaitForConditionOrTimeOut(() => clientComponent.OnLostOwnershipFired);
Assert.False(s_GlobalTimeoutHelper.TimedOut, $"Timed out waiting for client to lose ownership!");
Assert.That(clientComponent.OnLostOwnershipFired);
Assert.That(clientComponent.OwnerClientId, Is.EqualTo(m_ServerNetworkManager.LocalClientId));
yield return WaitForConditionOrTimeOut(() => clientComponent.OnLostOwnershipFired && clientComponent.OwnerClientId == m_ServerNetworkManager.LocalClientId);
AssertOnTimeout($"Timed out waiting for client-side lose ownership event to trigger or owner identifier to be equal to the host!");
}
/// <summary>
@@ -193,11 +240,11 @@ namespace Unity.Netcode.RuntimeTests
m_ServerNetworkManager.SpawnManager.RemoveOwnership(m_OwnershipNetworkObject);
var serverObject = m_ServerNetworkManager.SpawnManager.SpawnedObjects[ownershipNetworkObjectId];
Assert.That(serverObject, Is.Not.Null);
var clientObject = (NetworkObject)null;
var clientObjects = new List<NetworkObject>();
for (int i = 0; i < NumberOfClients; i++)
{
var clientObject = m_ClientNetworkManagers[i].SpawnManager.SpawnedObjects[ownershipNetworkObjectId];
clientObject = m_ClientNetworkManagers[i].SpawnManager.SpawnedObjects[ownershipNetworkObjectId];
Assert.That(clientObject, Is.Not.Null);
clientObjects.Add(clientObject);
}
@@ -217,9 +264,10 @@ namespace Unity.Netcode.RuntimeTests
// After the 1st client has been given ownership to the object, this will be used to make sure each previous owner properly received the remove ownership message
var previousClientComponent = (NetworkObjectOwnershipComponent)null;
for (int clientIndex = 0; clientIndex < NumberOfClients; clientIndex++)
{
var clientObject = clientObjects[clientIndex];
clientObject = clientObjects[clientIndex];
var clientId = m_ClientNetworkManagers[clientIndex].LocalClientId;
Assert.That(m_ServerNetworkManager.ConnectedClients.ContainsKey(clientId));
@@ -271,7 +319,15 @@ namespace Unity.Netcode.RuntimeTests
else
{
// Validates that when ownership is removed the server gets an OnGainedOwnership notification
serverObject.RemoveOwnership();
// In distributed authority mode, the current owner just rolls the ownership back over to the DAHost client (i.e. host mocking CMB Service)
if (m_DistributedAuthority)
{
clientObject.ChangeOwnership(NetworkManager.ServerClientId);
}
else
{
serverObject.RemoveOwnership();
}
}
yield return WaitForConditionOrTimeOut(ownershipMessageHooks);

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

@@ -6,6 +6,9 @@ using UnityEngine.TestTools;
namespace Unity.Netcode.RuntimeTests
{
[TestFixture(SessionModeTypes.ClientServer)]
[TestFixture(SessionModeTypes.DistributedAuthority)]
public class NetworkObjectSpawnManyObjectsTests : NetcodeIntegrationTest
{
protected override int NumberOfClients => 1;
@@ -15,6 +18,7 @@ namespace Unity.Netcode.RuntimeTests
private NetworkPrefab m_PrefabToSpawn;
public NetworkObjectSpawnManyObjectsTests(SessionModeTypes sessionModeType) : base(sessionModeType) { }
// Using this component assures we will know precisely how many prefabs were spawned on the client
public class SpawnObjecTrackingComponent : NetworkBehaviour
{
@@ -35,6 +39,7 @@ namespace Unity.Netcode.RuntimeTests
var gameObject = new GameObject("TestObject");
var networkObject = gameObject.AddComponent<NetworkObject>();
NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(networkObject);
networkObject.IsSceneObject = false;
gameObject.AddComponent<SpawnObjecTrackingComponent>();
m_PrefabToSpawn = new NetworkPrefab() { Prefab = gameObject };

189
Tests/Runtime/NetworkObject/NetworkObjectSynchronizationTests.cs
View File

@@ -8,6 +8,8 @@ using Random = UnityEngine.Random;
namespace Unity.Netcode.RuntimeTests
{
[TestFixture(VariableLengthSafety.DisableNetVarSafety, HostOrServer.DAHost)]
[TestFixture(VariableLengthSafety.DisableNetVarSafety, HostOrServer.Host)]
[TestFixture(VariableLengthSafety.EnabledNetVarSafety, HostOrServer.Host)]
[TestFixture(VariableLengthSafety.DisableNetVarSafety, HostOrServer.Server)]
@@ -29,17 +31,20 @@ namespace Unity.Netcode.RuntimeTests
{
DisableNetVarSafety,
EnabledNetVarSafety,
}
};
public NetworkObjectSynchronizationTests(VariableLengthSafety variableLengthSafety, HostOrServer hostOrServer)
public NetworkObjectSynchronizationTests(VariableLengthSafety variableLengthSafety, HostOrServer hostOrServer) : base(hostOrServer)
{
m_VariableLengthSafety = variableLengthSafety;
m_UseHost = hostOrServer == HostOrServer.Host;
}
protected override void OnCreatePlayerPrefab()
{
m_PlayerPrefab.AddComponent<NetworkBehaviourWithOwnerNetworkVariables>();
var component = m_PlayerPrefab.AddComponent<NetworkBehaviourWithOwnerNetworkVariables>();
if (m_DistributedAuthority)
{
component.SetWritePermissions(NetworkVariableWritePermission.Owner);
}
base.OnCreatePlayerPrefab();
}
@@ -123,40 +128,64 @@ namespace Unity.Netcode.RuntimeTests
if (m_UseHost)
{
var delayCounter = 0;
while (m_ClientNetworkManagers.Length == 0)
{
delayCounter++;
Assert.True(delayCounter < 30, "TimeOut waiting for client to spawn!");
yield return s_DefaultWaitForTick;
}
delayCounter = 0;
while (!m_PlayerNetworkObjects[m_ServerNetworkManager.LocalClientId].ContainsKey(m_ClientNetworkManagers[0].LocalClientId))
{
delayCounter++;
if (delayCounter >= 30)
{
VerboseDebug("Trap!");
}
Assert.True(delayCounter < 30, "TimeOut waiting for client to spawn!");
yield return s_DefaultWaitForTick;
}
var serverSideClientPlayerComponent = m_PlayerNetworkObjects[m_ServerNetworkManager.LocalClientId][m_ClientNetworkManagers[0].LocalClientId].GetComponent<NetworkBehaviourWithOwnerNetworkVariables>();
var serverSideHostPlayerComponent = m_ServerNetworkManager.LocalClient.PlayerObject.GetComponent<NetworkBehaviourWithOwnerNetworkVariables>();
var clientSidePlayerComponent = m_ClientNetworkManagers[0].LocalClient.PlayerObject.GetComponent<NetworkBehaviourWithOwnerNetworkVariables>();
var clientSideHostPlayerComponent = m_PlayerNetworkObjects[m_ClientNetworkManagers[0].LocalClientId][m_ServerNetworkManager.LocalClientId].GetComponent<NetworkBehaviourWithOwnerNetworkVariables>();
var modeText = m_DistributedAuthority ? "owner" : "server";
// Validate that the client side player values match the server side value of the client's player
Assert.IsTrue(serverSideClientPlayerComponent.NetworkVariableData1.Value == clientSidePlayerComponent.NetworkVariableData1.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData1)}][Client Player] Client side value ({serverSideClientPlayerComponent.NetworkVariableData1.Value})" +
$" does not equal the server side value ({serverSideClientPlayerComponent.NetworkVariableData1.Value})!");
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData1)}][Client Player-{clientSidePlayerComponent.OwnerClientId}] Client side value ({clientSidePlayerComponent.NetworkVariableData1.Value})" +
$" does not equal the {modeText} side value ({serverSideClientPlayerComponent.NetworkVariableData1.Value})!");
Assert.IsTrue(serverSideClientPlayerComponent.NetworkVariableData2.Value == clientSidePlayerComponent.NetworkVariableData2.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData2)}][Client Player] Client side value ({serverSideClientPlayerComponent.NetworkVariableData2.Value})" +
$" does not equal the server side value ({serverSideClientPlayerComponent.NetworkVariableData2.Value})!");
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData2)}][Client Player-{clientSidePlayerComponent.OwnerClientId}] Client side value ({clientSidePlayerComponent.NetworkVariableData2.Value})" +
$" does not equal the {modeText} side value ({serverSideClientPlayerComponent.NetworkVariableData2.Value})!");
Assert.IsTrue(serverSideClientPlayerComponent.NetworkVariableData3.Value == clientSidePlayerComponent.NetworkVariableData3.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData3)}][Client Player] Client side value ({serverSideClientPlayerComponent.NetworkVariableData3.Value})" +
$" does not equal the server side value ({serverSideClientPlayerComponent.NetworkVariableData3.Value})!");
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData3)}][Client Player-{clientSidePlayerComponent.OwnerClientId}] Client side value ({clientSidePlayerComponent.NetworkVariableData3.Value})" +
$" does not equal the {modeText} side value ({serverSideClientPlayerComponent.NetworkVariableData3.Value})!");
Assert.IsTrue(serverSideClientPlayerComponent.NetworkVariableData4.Value == clientSidePlayerComponent.NetworkVariableData4.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData4)}][Client Player] Client side value ({serverSideClientPlayerComponent.NetworkVariableData4.Value})" +
$" does not equal the server side value ({serverSideClientPlayerComponent.NetworkVariableData4.Value})!");
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData4)}][Client Player-{clientSidePlayerComponent.OwnerClientId}] Client side value ({clientSidePlayerComponent.NetworkVariableData4.Value})" +
$" does not equal the {modeText} side value ({serverSideClientPlayerComponent.NetworkVariableData4.Value})!");
// Validate that only the 2nd and 4th NetworkVariable on the client side instance of the host's player is the same and the other two do not match
// (i.e. NetworkVariables owned by the server should not get synchronized on client)
Assert.IsTrue(serverSideHostPlayerComponent.NetworkVariableData1.Value != clientSideHostPlayerComponent.NetworkVariableData1.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData1)}][Host Player] Client side value ({serverSideHostPlayerComponent.NetworkVariableData1.Value})" +
$" should not be equal to the server side value ({clientSideHostPlayerComponent.NetworkVariableData1.Value})!");
Assert.IsTrue(serverSideHostPlayerComponent.NetworkVariableData2.Value == clientSideHostPlayerComponent.NetworkVariableData2.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData2)}][Host Player] Client side value ({serverSideHostPlayerComponent.NetworkVariableData2.Value})" +
$" does not equal the server side value ({clientSideHostPlayerComponent.NetworkVariableData2.Value})!");
Assert.IsTrue(serverSideHostPlayerComponent.NetworkVariableData3.Value != clientSideHostPlayerComponent.NetworkVariableData3.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData3)}][Host Player] Client side value ({serverSideHostPlayerComponent.NetworkVariableData3.Value})" +
$" should not be equal to the server side value ({clientSideHostPlayerComponent.NetworkVariableData3.Value})!");
Assert.IsTrue(serverSideHostPlayerComponent.NetworkVariableData4.Value == clientSideHostPlayerComponent.NetworkVariableData4.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData4)}][Host Player] Client side value ({serverSideHostPlayerComponent.NetworkVariableData4.Value})" +
$" does not equal the server side value ({clientSideHostPlayerComponent.NetworkVariableData4.Value})!");
// DANGO-TODO: This scenario is only possible to do if we add a DA-Server to mock the CMB Service or we integrate the CMB Service AND we have updated NetworkVariable permissions
// to only allow the service to write. For now, we will skip this validation for distributed authority
if (!m_DistributedAuthority)
{
// Validate that only the 2nd and 4th NetworkVariable on the client side instance of the host's player is the same and the other two do not match
// (i.e. NetworkVariables owned by the server should not get synchronized on client)
Assert.IsTrue(serverSideHostPlayerComponent.NetworkVariableData1.Value != clientSideHostPlayerComponent.NetworkVariableData1.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData1)}][Host Player] Client side value ({clientSideHostPlayerComponent.NetworkVariableData1.Value})" +
$" should not be equal to the server side value ({serverSideHostPlayerComponent.NetworkVariableData1.Value})!");
Assert.IsTrue(serverSideHostPlayerComponent.NetworkVariableData2.Value == clientSideHostPlayerComponent.NetworkVariableData2.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData2)}][Host Player] Client side value ({clientSideHostPlayerComponent.NetworkVariableData2.Value})" +
$" does not equal the server side value ({serverSideHostPlayerComponent.NetworkVariableData2.Value})!");
Assert.IsTrue(serverSideHostPlayerComponent.NetworkVariableData3.Value != clientSideHostPlayerComponent.NetworkVariableData3.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData3)}][Host Player] Client side value ({clientSideHostPlayerComponent.NetworkVariableData3.Value})" +
$" should not be equal to the server side value ({serverSideHostPlayerComponent.NetworkVariableData3.Value})!");
Assert.IsTrue(serverSideHostPlayerComponent.NetworkVariableData4.Value == serverSideHostPlayerComponent.NetworkVariableData4.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData4)}][Host Player] Client side value ({clientSideHostPlayerComponent.NetworkVariableData4.Value})" +
$" does not equal the server side value ({serverSideHostPlayerComponent.NetworkVariableData4.Value})!");
}
}
else
{
@@ -190,44 +219,53 @@ namespace Unity.Netcode.RuntimeTests
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData4)}][Player-{clientOneId}] Client-{clientOneId} value ({clientSide1PlayerComponent.NetworkVariableData4.Value})" +
$" does not equal Client-{clientTwoId}'s clone side value ({clientSide2Player1Clone.NetworkVariableData4.Value})!");
// DANGO-TODO: This scenario is only possible to do if we add a DA-Server to mock the CMB Service or we integrate the CMB Service AND we have updated NetworkVariable permissions
// to only allow the service to write. For now, we will skip this validation for distributed authority
if (!m_DistributedAuthority)
{
// Validate that client two's 2nd and 4th NetworkVariables for the local and clone instances match and the other two do not
Assert.IsTrue(clientSide2PlayerComponent.NetworkVariableData1.Value != clientSide1Player2Clone.NetworkVariableData1.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData1)}][Player-{clientTwoId}] Client-{clientTwoId} value ({clientSide2PlayerComponent.NetworkVariableData1.Value})" +
$" should not be equal to Client-{clientOneId}'s clone side value ({clientSide1Player2Clone.NetworkVariableData1.Value})!");
// Validate that client two's 2nd and 4th NetworkVariables for the local and clone instances match and the other two do not
Assert.IsTrue(clientSide2PlayerComponent.NetworkVariableData1.Value != clientSide1Player2Clone.NetworkVariableData1.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData1)}][Player-{clientTwoId}] Client-{clientTwoId} value ({clientSide2PlayerComponent.NetworkVariableData1.Value})" +
$" should not be equal to Client-{clientOneId}'s clone side value ({clientSide1Player2Clone.NetworkVariableData1.Value})!");
Assert.IsTrue(clientSide2PlayerComponent.NetworkVariableData2.Value == clientSide1Player2Clone.NetworkVariableData2.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData2)}][Player-{clientTwoId}] Client-{clientTwoId} value ({clientSide2PlayerComponent.NetworkVariableData2.Value})" +
$" does not equal Client-{clientOneId}'s clone side value ({clientSide1Player2Clone.NetworkVariableData2.Value})!");
Assert.IsTrue(clientSide2PlayerComponent.NetworkVariableData2.Value == clientSide1Player2Clone.NetworkVariableData2.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData2)}][Player-{clientTwoId}] Client-{clientTwoId} value ({clientSide2PlayerComponent.NetworkVariableData2.Value})" +
$" does not equal Client-{clientOneId}'s clone side value ({clientSide1Player2Clone.NetworkVariableData2.Value})!");
Assert.IsTrue(clientSide2PlayerComponent.NetworkVariableData3.Value != clientSide1Player2Clone.NetworkVariableData3.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData3)}][Player-{clientTwoId}] Client-{clientTwoId} value ({clientSide2PlayerComponent.NetworkVariableData3.Value})" +
$" should not be equal to Client-{clientOneId}'s clone side value ({clientSide1Player2Clone.NetworkVariableData3.Value})!");
Assert.IsTrue(clientSide2PlayerComponent.NetworkVariableData3.Value != clientSide1Player2Clone.NetworkVariableData3.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData3)}][Player-{clientTwoId}] Client-{clientTwoId} value ({clientSide2PlayerComponent.NetworkVariableData3.Value})" +
$" should not be equal to Client-{clientOneId}'s clone side value ({clientSide1Player2Clone.NetworkVariableData3.Value})!");
Assert.IsTrue(clientSide2PlayerComponent.NetworkVariableData4.Value == clientSide1Player2Clone.NetworkVariableData4.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData4)}][Player-{clientTwoId}] Client-{clientTwoId} value ({clientSide2PlayerComponent.NetworkVariableData4.Value})" +
$" does not equal Client-{clientOneId}'s clone side value ({clientSide1Player2Clone.NetworkVariableData4.Value})!");
Assert.IsTrue(clientSide2PlayerComponent.NetworkVariableData4.Value == clientSide1Player2Clone.NetworkVariableData4.Value,
$"[{nameof(NetworkBehaviourWithOwnerNetworkVariables.NetworkVariableData4)}][Player-{clientTwoId}] Client-{clientTwoId} value ({clientSide2PlayerComponent.NetworkVariableData4.Value})" +
$" does not equal Client-{clientOneId}'s clone side value ({clientSide1Player2Clone.NetworkVariableData4.Value})!");
}
}
// Now validate all of the NetworkVariable values match to assure everything synchronized properly
foreach (var spawnedObject in validSpawnedNetworkObjects)
// DANGO-TODO: This scenario is only possible to do if we add a DA-Server to mock the CMB Service or we integrate the CMB Service AND we have updated NetworkVariable permissions
// to only allow the service to write. For now, we will skip this validation for distributed authority
if (!m_DistributedAuthority)
{
foreach (var clientNetworkManager in m_ClientNetworkManagers)
// Now validate all of the NetworkVariable values match to assure everything synchronized properly
foreach (var spawnedObject in validSpawnedNetworkObjects)
{
//Validate that the connected client has spawned all of the instances that shouldn't have failed.
var clientSideNetworkObjects = s_GlobalNetworkObjects[clientNetworkManager.LocalClientId];
foreach (var clientNetworkManager in m_ClientNetworkManagers)
{
//Validate that the connected client has spawned all of the instances that shouldn't have failed.
var clientSideNetworkObjects = s_GlobalNetworkObjects[clientNetworkManager.LocalClientId];
Assert.IsTrue(NetworkBehaviourWithNetworkVariables.ClientSpawnCount[clientNetworkManager.LocalClientId] == validSpawnedNetworkObjects.Count, $"Client-{clientNetworkManager.LocalClientId} spawned " +
$"({NetworkBehaviourWithNetworkVariables.ClientSpawnCount}) {nameof(NetworkObject)}s but the expected number of {nameof(NetworkObject)}s should have been ({validSpawnedNetworkObjects.Count})!");
Assert.IsTrue(NetworkBehaviourWithNetworkVariables.ClientSpawnCount[clientNetworkManager.LocalClientId] == validSpawnedNetworkObjects.Count, $"Client-{clientNetworkManager.LocalClientId} spawned " +
$"({NetworkBehaviourWithNetworkVariables.ClientSpawnCount}) {nameof(NetworkObject)}s but the expected number of {nameof(NetworkObject)}s should have been ({validSpawnedNetworkObjects.Count})!");
var spawnedNetworkObject = spawnedObject.GetComponent<NetworkObject>();
Assert.IsTrue(clientSideNetworkObjects.ContainsKey(spawnedNetworkObject.NetworkObjectId), $"Failed to find valid spawned {nameof(NetworkObject)} on the client-side with a " +
$"{nameof(NetworkObject.NetworkObjectId)} of {spawnedNetworkObject.NetworkObjectId}");
var spawnedNetworkObject = spawnedObject.GetComponent<NetworkObject>();
Assert.IsTrue(clientSideNetworkObjects.ContainsKey(spawnedNetworkObject.NetworkObjectId), $"Failed to find valid spawned {nameof(NetworkObject)} on the client-side with a " +
$"{nameof(NetworkObject.NetworkObjectId)} of {spawnedNetworkObject.NetworkObjectId}");
var clientSideObject = clientSideNetworkObjects[spawnedNetworkObject.NetworkObjectId];
Assert.IsTrue(clientSideObject.NetworkManager == clientNetworkManager, $"Client-side object {clientSideObject}'s {nameof(NetworkManager)} is not valid!");
var clientSideObject = clientSideNetworkObjects[spawnedNetworkObject.NetworkObjectId];
Assert.IsTrue(clientSideObject.NetworkManager == clientNetworkManager, $"Client-side object {clientSideObject}'s {nameof(NetworkManager)} is not valid!");
ValidateNetworkBehaviourWithNetworkVariables(spawnedNetworkObject, clientSideObject);
ValidateNetworkBehaviourWithNetworkVariables(spawnedNetworkObject, clientSideObject);
}
}
}
}
@@ -259,6 +297,22 @@ namespace Unity.Netcode.RuntimeTests
$"does not match the client side instance value ({clientSideComponent.NetworkVariableData4.Value})!");
}
private bool ClientSpawnedNetworkObjects(List<GameObject> spawnedObjectList)
{
var clientSideNetworkObjects = s_GlobalNetworkObjects[m_ClientNetworkManagers[0].LocalClientId];
foreach (var spawnedObject in spawnedObjectList)
{
var serverSideSpawnedNetworkObject = spawnedObject.GetComponent<NetworkObject>();
if (!clientSideNetworkObjects.ContainsKey(serverSideSpawnedNetworkObject.NetworkObjectId))
{
return false;
}
}
return true;
}
/// <summary>
/// This validates that when a NetworkBehaviour fails serialization or deserialization during synchronizations that other NetworkBehaviours
/// will still be initialized properly
@@ -287,6 +341,9 @@ namespace Unity.Netcode.RuntimeTests
// Validate that when a NetworkBehaviour fails to synchronize and is skipped over it does not
// impact the rest of the NetworkBehaviours.
var clientSideNetworkObjects = s_GlobalNetworkObjects[m_ClientNetworkManagers[0].LocalClientId];
yield return WaitForConditionOrTimeOut(() => ClientSpawnedNetworkObjects(spawnedObjectList));
AssertOnTimeout($"Timed out waiting for newly joined client to spawn all NetworkObjects!");
foreach (var spawnedObject in spawnedObjectList)
{
var serverSideSpawnedNetworkObject = spawnedObject.GetComponent<NetworkObject>();
@@ -387,6 +444,24 @@ namespace Unity.Netcode.RuntimeTests
/// </summary>
public class NetworkBehaviourWithOwnerNetworkVariables : NetworkBehaviour
{
private NetworkVariableWritePermission m_NetworkVariableWritePermission = NetworkVariableWritePermission.Server;
/// <summary>
/// For distributed authority, there is no such thing as a server and only owners
/// DANGO-TODO: When NetworkVariable permissions are updated, this test might need to be updated
/// </summary>
/// <param name="networkVariableWritePermission"></param>
public void SetWritePermissions(NetworkVariableWritePermission networkVariableWritePermission)
{
m_NetworkVariableWritePermission = networkVariableWritePermission;
// Should synchronize with everyone
NetworkVariableData1 = new NetworkVariable<int>(default, NetworkVariableReadPermission.Everyone, networkVariableWritePermission);
// Should synchronize with everyone
NetworkVariableData2 = new NetworkVariable<long>(default, NetworkVariableReadPermission.Everyone, networkVariableWritePermission);
// Should synchronize with everyone
NetworkVariableData3 = new NetworkVariable<byte>(default, NetworkVariableReadPermission.Everyone, networkVariableWritePermission);
// Should synchronize with everyone
NetworkVariableData4 = new NetworkVariable<ushort>(default, NetworkVariableReadPermission.Everyone, networkVariableWritePermission);
}
// Should not synchronize on non-owners
public NetworkVariable<int> NetworkVariableData1 = new NetworkVariable<int>(default, NetworkVariableReadPermission.Owner, NetworkVariableWritePermission.Server);
@@ -399,7 +474,9 @@ namespace Unity.Netcode.RuntimeTests
public override void OnNetworkSpawn()
{
if (IsServer)
// Adjustment for distributed authority mode
if ((m_NetworkVariableWritePermission == NetworkVariableWritePermission.Server && IsServer && !NetworkManager.DistributedAuthorityMode) ||
(m_NetworkVariableWritePermission == NetworkVariableWritePermission.Owner && IsOwner && NetworkManager.DistributedAuthorityMode))
{
NetworkVariableData1.Value = Random.Range(1, 1000);
NetworkVariableData2.Value = Random.Range(1, 1000);