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

com.unity.netcode.gameobjects@1.4.0

Browse Source 
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).

## [1.4.0] - 2023-04-10

### Added

- Added a way to access the GlobalObjectIdHash via PrefabIdHash for use in the Connection Approval Callback. (#2437)
- Added `OnServerStarted` and `OnServerStopped` events that will trigger only on the server (or host player) to notify that the server just started or is no longer active (#2420)
- Added `OnClientStarted` and `OnClientStopped` events that will trigger only on the client (or host player) to notify that the client just started or is no longer active (#2420)
- Added `NetworkTransform.UseHalfFloatPrecision` property that, when enabled, will use half float values for position, rotation, and scale. This yields a 50% bandwidth savings a the cost of precision. (#2388)
- Added `NetworkTransform.UseQuaternionSynchronization` property that, when enabled, will synchronize the entire quaternion. (#2388)
- Added `NetworkTransform.UseQuaternionCompression` property that, when enabled, will use a smallest three implementation reducing a full quaternion synchronization update to the size of an unsigned integer. (#2388)
- Added `NetworkTransform.SlerpPosition` property that, when enabled along with interpolation being enabled, will interpolate using `Vector3.Slerp`. (#2388)
- Added `BufferedLinearInterpolatorVector3` that replaces the float version, is now used by `NetworkTransform`, and provides the ability to enable or disable `Slerp`. (#2388)
- Added `HalfVector3` used for scale when half float precision is enabled. (#2388)
- Added `HalfVector4` used for rotation when half float precision and quaternion synchronization is enabled. (#2388)
- Added `HalfVector3DeltaPosition` used for position when half float precision is enabled. This handles loss in position precision by updating only the delta position as opposed to the full position. (#2388)
- Added `NetworkTransform.GetSpaceRelativePosition` and `NetworkTransform.GetSpaceRelativeRotation` helper methods to return the proper values depending upon whether local or world space. (#2388)
- Added `NetworkTransform.OnAuthorityPushTransformState` virtual method that is invoked just prior to sending the `NetworkTransformState` to non-authoritative instances. This provides users with the ability to obtain more precise delta values for prediction related calculations. (#2388)
- Added `NetworkTransform.OnNetworkTransformStateUpdated` virtual method that is invoked just after the authoritative `NetworkTransformState` is applied. This provides users with the ability to obtain more precise delta values for prediction related calculations. (#2388)
- Added `NetworkTransform.OnInitialize`virtual method that is invoked after the `NetworkTransform` has been initialized or re-initialized when ownership changes. This provides for a way to make adjustments when `NetworkTransform` is initialized (i.e. resetting client prediction etc) (#2388)
- Added `NetworkObject.SynchronizeTransform` property (default is true) that provides users with another way to help with bandwidth optimizations where, when set to false, the `NetworkObject`'s associated transform will not be included when spawning and/or synchronizing late joining players. (#2388)
- Added `NetworkSceneManager.ActiveSceneSynchronizationEnabled` property, disabled by default, that enables client synchronization of server-side active scene changes. (#2383)
- Added `NetworkObject.ActiveSceneSynchronization`, disabled by default, that will automatically migrate a `NetworkObject` to a newly assigned active scene. (#2383)
- Added `NetworkObject.SceneMigrationSynchronization`, enabled by default, that will synchronize client(s) when a `NetworkObject` is migrated into a new scene on the server side via `SceneManager.MoveGameObjectToScene`. (#2383)

### Changed

- Made sure the `CheckObjectVisibility` delegate is checked and applied, upon `NetworkShow` attempt. Found while supporting (#2454), although this is not a fix for this (already fixed) issue. (#2463)
- Changed `NetworkTransform` authority handles delta checks on each new network tick and no longer consumes processing cycles checking for deltas for all frames in-between ticks. (#2388)
- Changed the `NetworkTransformState` structure is now public and now has public methods that provide access to key properties of the `NetworkTransformState` structure. (#2388)
- Changed `NetworkTransform` interpolation adjusts its interpolation "ticks ago" to be 2 ticks latent if it is owner authoritative and the instance is not the server or 1 tick latent if the instance is the server and/or is server authoritative. (#2388)
- Updated `NetworkSceneManager` to migrate dynamically spawned `NetworkObject`s with `DestroyWithScene` set to false into the active scene if their current scene is unloaded. (#2383)
- Updated the server to synchronize its local `NetworkSceneManager.ClientSynchronizationMode` during the initial client synchronization. (#2383)

### Fixed

- Fixed issue where during client synchronization the synchronizing client could receive a ObjectSceneChanged message before the client-side NetworkObject instance had been instantiated and spawned. (#2502)
- Fixed issue where `NetworkAnimator` was building client RPC parameters to exclude the host from sending itself messages but was not including it in the ClientRpc parameters. (#2492)
- Fixed issue where `NetworkAnimator` was not properly detecting and synchronizing cross fade initiated transitions. (#2481)
- Fixed issue where `NetworkAnimator` was not properly synchronizing animation state updates. (#2481)
- Fixed float NetworkVariables not being rendered properly in the inspector of NetworkObjects. (#2441)
- Fixed an issue where Named Message Handlers could remove themselves causing an exception when the metrics tried to access the name of the message.(#2426)
- Fixed registry of public `NetworkVariable`s in derived `NetworkBehaviour`s (#2423)
- Fixed issue where runtime association of `Animator` properties to `AnimationCurve`s would cause `NetworkAnimator` to attempt to update those changes. (#2416)
- Fixed issue where `NetworkAnimator` would not check if its associated `Animator` was valid during serialization and would spam exceptions in the editor console. (#2416)
- Fixed issue with a child's rotation rolling over when interpolation is enabled on a `NetworkTransform`. Now using half precision or full quaternion synchronization will always update all axis. (#2388)
- Fixed issue where `NetworkTransform` was not setting the teleport flag when the `NetworkTransform.InLocalSpace` value changed. This issue only impacted `NetworkTransform` when interpolation was enabled. (#2388)
- Fixed issue when the `NetworkSceneManager.ClientSynchronizationMode` is `LoadSceneMode.Additive` and the server changes the currently active scene prior to a client connecting then upon a client connecting and being synchronized the NetworkSceneManager would clear its internal ScenePlacedObjects list that could already be populated. (#2383)
- Fixed issue where a client would load duplicate scenes of already preloaded scenes during the initial client synchronization and `NetworkSceneManager.ClientSynchronizationMode` was set to `LoadSceneMode.Additive`. (#2383)
This commit is contained in:
Unity Technologies
2023-04-10 00:00:00 +00:00
parent 8060718e04
commit b5abc3ff7c
138 changed files with 7892 additions and 1852 deletions
Download Patch File Download Diff File Expand all files Collapse all files

545
TestHelpers/Runtime/IntegrationTestSceneHandler.cs
View File

@@ -15,6 +15,16 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// </summary>
internal class IntegrationTestSceneHandler : ISceneManagerHandler, IDisposable
{
private Scene m_InvalidScene = new Scene();
internal struct SceneEntry
{
public bool IsAssigned;
public Scene Scene;
}
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
internal static List<NetworkManager> NetworkManagers = new List<NetworkManager>();
@@ -96,7 +106,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// Processes scene loading jobs
/// </summary>
/// <param name="queuedSceneJob">job to process</param>
static internal IEnumerator ProcessLoadingSceneJob(QueuedSceneJob queuedSceneJob)
internal static IEnumerator ProcessLoadingSceneJob(QueuedSceneJob queuedSceneJob)
{
var itegrationTestSceneHandler = queuedSceneJob.IntegrationTestSceneHandler;
while (!itegrationTestSceneHandler.OnCanClientsLoad())
@@ -170,7 +180,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// Processes scene unloading jobs
/// </summary>
/// <param name="queuedSceneJob">job to process</param>
static internal IEnumerator ProcessUnloadingSceneJob(QueuedSceneJob queuedSceneJob)
internal static IEnumerator ProcessUnloadingSceneJob(QueuedSceneJob queuedSceneJob)
{
var itegrationTestSceneHandler = queuedSceneJob.IntegrationTestSceneHandler;
while (!itegrationTestSceneHandler.OnCanClientsUnload())
@@ -213,7 +223,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// Processes all jobs within the queue.
/// When all jobs are finished, the coroutine stops.
/// </summary>
static internal IEnumerator JobQueueProcessor()
internal static IEnumerator JobQueueProcessor()
{
while (QueuedSceneJobs.Count != 0)
{
@@ -267,8 +277,8 @@ namespace Unity.Netcode.TestHelpers.Runtime
{
if (m_ServerSceneBeingLoaded == scene.name)
{
ProcessInSceneObjects(scene, NetworkManager);
SceneManager.sceneLoaded -= Sever_SceneLoaded;
ProcessInSceneObjects(scene, NetworkManager);
}
}
@@ -330,6 +340,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
{
continue;
}
if (networkManager.SceneManager.ScenesLoaded.ContainsKey(sceneLoaded.handle))
{
if (NetworkManager.LogLevel == LogLevel.Developer)
@@ -347,7 +358,12 @@ namespace Unity.Netcode.TestHelpers.Runtime
{
NetworkLog.LogInfo($"{NetworkManager.name} adding {sceneLoaded.name} with a handle of {sceneLoaded.handle} to its ScenesLoaded.");
}
if (DoesANetworkManagerHoldThisScene(sceneLoaded))
{
continue;
}
NetworkManager.SceneManager.ScenesLoaded.Add(sceneLoaded.handle, sceneLoaded);
StartTrackingScene(sceneLoaded, true, NetworkManager);
return sceneLoaded;
}
}
@@ -365,6 +381,521 @@ namespace Unity.Netcode.TestHelpers.Runtime
return true;
}
public void ClearSceneTracking(NetworkManager networkManager)
{
SceneNameToSceneHandles.Clear();
}
public void StopTrackingScene(int handle, string name, NetworkManager networkManager)
{
if (!SceneNameToSceneHandles.ContainsKey(networkManager))
{
return;
}
if (SceneNameToSceneHandles[networkManager].ContainsKey(name))
{
if (SceneNameToSceneHandles[networkManager][name].ContainsKey(handle))
{
SceneNameToSceneHandles[networkManager][name].Remove(handle);
if (SceneNameToSceneHandles[networkManager][name].Count == 0)
{
SceneNameToSceneHandles[networkManager].Remove(name);
}
}
}
}
public void StartTrackingScene(Scene scene, bool assigned, NetworkManager networkManager)
{
if (!SceneNameToSceneHandles.ContainsKey(networkManager))
{
SceneNameToSceneHandles.Add(networkManager, new Dictionary<string, Dictionary<int, SceneEntry>>());
}
if (!SceneNameToSceneHandles[networkManager].ContainsKey(scene.name))
{
SceneNameToSceneHandles[networkManager].Add(scene.name, new Dictionary<int, SceneEntry>());
}
if (!SceneNameToSceneHandles[networkManager][scene.name].ContainsKey(scene.handle))
{
var sceneEntry = new SceneEntry()
{
IsAssigned = true,
Scene = scene
};
SceneNameToSceneHandles[networkManager][scene.name].Add(scene.handle, sceneEntry);
}
}
private bool DoesANetworkManagerHoldThisScene(Scene scene)
{
foreach (var netManEntry in SceneNameToSceneHandles)
{
if (!netManEntry.Value.ContainsKey(scene.name))
{
continue;
}
// The other NetworkManager only has to have an entry to
// disqualify this scene instance
if (netManEntry.Value[scene.name].ContainsKey(scene.handle))
{
return true;
}
}
return false;
}
public bool DoesSceneHaveUnassignedEntry(string sceneName, NetworkManager networkManager)
{
var scenesWithSceneName = new List<Scene>();
var scenesAssigned = new List<Scene>();
for (int i = 0; i < SceneManager.sceneCount; i++)
{
var scene = SceneManager.GetSceneAt(i);
if (scene.name == sceneName)
{
scenesWithSceneName.Add(scene);
}
}
// Check for other NetworkManager instances already having been assigned this scene
foreach (var netManEntry in SceneNameToSceneHandles)
{
// Ignore this NetworkManager instance at this stage
if (netManEntry.Key == networkManager)
{
continue;
}
foreach (var scene in scenesWithSceneName)
{
if (!netManEntry.Value.ContainsKey(scene.name))
{
continue;
}
// The other NetworkManager only has to have an entry to
// disqualify this scene instance
if (netManEntry.Value[scene.name].ContainsKey(scene.handle))
{
scenesAssigned.Add(scene);
}
}
}
// Remove all of the assigned scenes from the list of scenes with the
// passed in scene name.
foreach (var assignedScene in scenesAssigned)
{
if (scenesWithSceneName.Contains(assignedScene))
{
scenesWithSceneName.Remove(assignedScene);
}
}
// If all currently loaded scenes with the scene name are taken
// then we return false
if (scenesWithSceneName.Count == 0)
{
return false;
}
// If we made it here, then no other NetworkManager is tracking this scene
// and if we don't have an entry for this NetworkManager then we can use any
// of the remaining scenes loaded with that name.
if (!SceneNameToSceneHandles.ContainsKey(networkManager))
{
return true;
}
// If we don't yet have a scene name in this NetworkManager's lookup table,
// then we can use any of the remaining availabel scenes with that scene name
if (!SceneNameToSceneHandles[networkManager].ContainsKey(sceneName))
{
return true;
}
foreach (var scene in scenesWithSceneName)
{
// If we don't have an entry for this scene handle (with the scene name) then we
// can use that scene
if (!SceneNameToSceneHandles[networkManager][scene.name].ContainsKey(scene.handle))
{
return true;
}
// This entry is not assigned, then we can use the associated scene
if (!SceneNameToSceneHandles[networkManager][scene.name][scene.handle].IsAssigned)
{
return true;
}
}
// None of the scenes with the same scene name can be used
return false;
}
public Scene GetSceneFromLoadedScenes(string sceneName, NetworkManager networkManager)
{
if (!SceneNameToSceneHandles.ContainsKey(networkManager))
{
return m_InvalidScene;
}
if (SceneNameToSceneHandles[networkManager].ContainsKey(sceneName))
{
foreach (var sceneHandleEntry in SceneNameToSceneHandles[networkManager][sceneName])
{
if (!sceneHandleEntry.Value.IsAssigned)
{
var sceneEntry = sceneHandleEntry.Value;
sceneEntry.IsAssigned = true;
SceneNameToSceneHandles[networkManager][sceneName][sceneHandleEntry.Key] = sceneEntry;
return sceneEntry.Scene;
}
}
}
// This is tricky since NetworkManager instances share the same scene hierarchy during integration tests.
// TODO 2023: Determine if there is a better way to associate the active scene for client NetworkManager instances.
var activeScene = SceneManager.GetActiveScene();
if (sceneName == activeScene.name && networkManager.SceneManager.ClientSynchronizationMode == LoadSceneMode.Additive)
{
// For now, just return the current active scene
// Note: Clients will not be able to synchronize in-scene placed NetworkObjects in an integration test for
// scenes loaded that have in-scene placed NetworkObjects prior to the clients joining (i.e. there will only
// ever be one instance of the active scene). To test in-scene placed NetworkObjects and make an integration
// test loaded scene be the active scene, don't set scene as an active scene on the server side until all
// clients have connected and loaded the scene.
return activeScene;
}
// If we found nothing return an invalid scene
return m_InvalidScene;
}
public void PopulateLoadedScenes(ref Dictionary<int, Scene> scenesLoaded, NetworkManager networkManager)
{
if (!SceneNameToSceneHandles.ContainsKey(networkManager))
{
SceneNameToSceneHandles.Add(networkManager, new Dictionary<string, Dictionary<int, SceneEntry>>());
}
var sceneCount = SceneManager.sceneCount;
for (int i = 0; i < sceneCount; i++)
{
var scene = SceneManager.GetSceneAt(i);
// Ignore scenes that belong to other NetworkManager instances
if (DoesANetworkManagerHoldThisScene(scene))
{
continue;
}
if (!DoesSceneHaveUnassignedEntry(scene.name, networkManager))
{
continue;
}
if (!SceneNameToSceneHandles[networkManager].ContainsKey(scene.name))
{
SceneNameToSceneHandles[networkManager].Add(scene.name, new Dictionary<int, SceneEntry>());
}
if (!SceneNameToSceneHandles[networkManager][scene.name].ContainsKey(scene.handle))
{
var sceneEntry = new SceneEntry()
{
IsAssigned = false,
Scene = scene
};
SceneNameToSceneHandles[networkManager][scene.name].Add(scene.handle, sceneEntry);
if (!scenesLoaded.ContainsKey(scene.handle))
{
scenesLoaded.Add(scene.handle, scene);
}
}
else
{
throw new Exception($"[{networkManager.LocalClient.PlayerObject.name}][Duplicate Handle] Scene {scene.name} already has scene handle {scene.handle} registered!");
}
}
}
private Dictionary<Scene, NetworkManager> m_ScenesToUnload = new Dictionary<Scene, NetworkManager>();
/// <summary>
/// Handles unloading any scenes that might remain on a client that
/// need to be unloaded.
/// </summary>
/// <param name="networkManager"></param>
public void UnloadUnassignedScenes(NetworkManager networkManager = null)
{
if (!SceneNameToSceneHandles.ContainsKey(networkManager))
{
return;
}
var relativeSceneNameToSceneHandles = SceneNameToSceneHandles[networkManager];
var sceneManager = networkManager.SceneManager;
SceneManager.sceneUnloaded += SceneManager_SceneUnloaded;
foreach (var sceneEntry in relativeSceneNameToSceneHandles)
{
var scenHandleEntries = relativeSceneNameToSceneHandles[sceneEntry.Key];
foreach (var sceneHandleEntry in scenHandleEntries)
{
if (!sceneHandleEntry.Value.IsAssigned)
{
if (sceneManager.VerifySceneBeforeUnloading == null || sceneManager.VerifySceneBeforeUnloading.Invoke(sceneHandleEntry.Value.Scene))
{
m_ScenesToUnload.Add(sceneHandleEntry.Value.Scene, networkManager);
}
}
}
}
foreach (var sceneToUnload in m_ScenesToUnload)
{
SceneManager.UnloadSceneAsync(sceneToUnload.Key);
}
}
/// <summary>
/// Removes the scene entry from the scene name to scene handle table
/// </summary>
private void SceneManager_SceneUnloaded(Scene scene)
{
if (m_ScenesToUnload.ContainsKey(scene))
{
var networkManager = m_ScenesToUnload[scene];
var relativeSceneNameToSceneHandles = SceneNameToSceneHandles[networkManager];
if (relativeSceneNameToSceneHandles.ContainsKey(scene.name))
{
var scenHandleEntries = relativeSceneNameToSceneHandles[scene.name];
if (scenHandleEntries.ContainsKey(scene.handle))
{
scenHandleEntries.Remove(scene.handle);
if (scenHandleEntries.Count == 0)
{
relativeSceneNameToSceneHandles.Remove(scene.name);
}
m_ScenesToUnload.Remove(scene);
if (m_ScenesToUnload.Count == 0)
{
SceneManager.sceneUnloaded -= SceneManager_SceneUnloaded;
}
}
}
}
}
/// <summary>
/// Integration test version that handles migrating dynamically spawned NetworkObjects to
/// the DDOL when a scene is unloaded
/// </summary>
/// <param name="networkManager"><see cref="NetworkManager"/> relative instance</param>
/// <param name="scene">scene being unloaded</param>
public void MoveObjectsFromSceneToDontDestroyOnLoad(ref NetworkManager networkManager, Scene scene)
{
// Create a local copy of the spawned objects list since the spawn manager will adjust the list as objects
// are despawned.
#if UNITY_2023_1_OR_NEWER
var networkObjects = Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID).Where((c) => c.IsSpawned);
#else
var networkObjects = Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsSpawned);
#endif
foreach (var networkObject in networkObjects)
{
if (networkObject == null || (networkObject != null && networkObject.gameObject.scene.handle != scene.handle))
{
if (networkObject != null)
{
VerboseDebug($"[MoveObjects from {scene.name} | {scene.handle}] Ignoring {networkObject.gameObject.name} because it isn't in scene {networkObject.gameObject.scene.name} ");
}
continue;
}
bool skipPrefab = false;
foreach (var networkPrefab in networkManager.NetworkConfig.Prefabs.Prefabs)
{
if (networkPrefab.Prefab == null)
{
continue;
}
if (networkObject == networkPrefab.Prefab.GetComponent<NetworkObject>())
{
skipPrefab = true;
break;
}
}
if (skipPrefab)
{
continue;
}
// Only NetworkObjects marked to not be destroyed with the scene and are not already in the DDOL are preserved
if (!networkObject.DestroyWithScene && networkObject.gameObject.scene != networkManager.SceneManager.DontDestroyOnLoadScene)
{
// Only move dynamically spawned NetworkObjects with no parent as the children will follow
if (networkObject.gameObject.transform.parent == null && networkObject.IsSceneObject != null && !networkObject.IsSceneObject.Value)
{
VerboseDebug($"[MoveObjects from {scene.name} | {scene.handle}] Moving {networkObject.gameObject.name} because it is in scene {networkObject.gameObject.scene.name} with DWS = {networkObject.DestroyWithScene}.");
Object.DontDestroyOnLoad(networkObject.gameObject);
}
}
else if (networkManager.IsServer)
{
if (networkObject.NetworkManager == networkManager)
{
VerboseDebug($"[MoveObjects from {scene.name} | {scene.handle}] Destroying {networkObject.gameObject.name} because it is in scene {networkObject.gameObject.scene.name} with DWS = {networkObject.DestroyWithScene}.");
networkObject.Despawn();
}
else //For integration testing purposes, migrate remaining into DDOL
{
VerboseDebug($"[MoveObjects from {scene.name} | {scene.handle}] Temporarily migrating {networkObject.gameObject.name} into DDOL to await server destroy message.");
Object.DontDestroyOnLoad(networkObject.gameObject);
}
}
}
}
/// <summary>
/// Sets the client synchronization mode which impacts whether both the server or client take into consideration scenes loaded before
/// starting the <see cref="NetworkManager"/>.
/// </summary>
/// <remarks>
/// <see cref="LoadSceneMode.Single"/>: Does not take preloaded scenes into consideration
/// <see cref="LoadSceneMode.Single"/>: Does take preloaded scenes into consideration
/// </remarks>
/// <param name="networkManager">relative <see cref="NetworkManager"/> instance</param>
/// <param name="mode"><see cref="LoadSceneMode.Single"/> or <see cref="LoadSceneMode.Additive"/></param>
public void SetClientSynchronizationMode(ref NetworkManager networkManager, LoadSceneMode mode)
{
var sceneManager = networkManager.SceneManager;
// Don't let client's set this value
if (!networkManager.IsServer)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning("Clients should not set this value as it is automatically synchronized with the server's setting!");
}
return;
}
else if (networkManager.ConnectedClientsIds.Count > (networkManager.IsHost ? 1 : 0) && sceneManager.ClientSynchronizationMode != mode)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning("Server is changing client synchronization mode after clients have been synchronized! It is recommended to do this before clients are connected!");
}
}
// For additive client synchronization, we take into consideration scenes
// already loaded.
if (mode == LoadSceneMode.Additive)
{
if (networkManager.IsServer)
{
sceneManager.OnSceneEvent -= SceneManager_OnSceneEvent;
sceneManager.OnSceneEvent += SceneManager_OnSceneEvent;
}
if (!SceneNameToSceneHandles.ContainsKey(networkManager))
{
SceneNameToSceneHandles.Add(networkManager, new Dictionary<string, Dictionary<int, SceneEntry>>());
}
var networkManagerScenes = SceneNameToSceneHandles[networkManager];
for (int i = 0; i < SceneManager.sceneCount; i++)
{
var scene = SceneManager.GetSceneAt(i);
// Ignore scenes that belong to other NetworkManager instances
if (!DoesSceneHaveUnassignedEntry(scene.name, networkManager))
{
continue;
}
// If using scene verification
if (sceneManager.VerifySceneBeforeLoading != null)
{
// Determine if we should take this scene into consideration
if (!sceneManager.VerifySceneBeforeLoading.Invoke(scene.buildIndex, scene.name, LoadSceneMode.Additive))
{
continue;
}
}
// If the scene is not already in the ScenesLoaded list, then add it
if (!sceneManager.ScenesLoaded.ContainsKey(scene.handle))
{
StartTrackingScene(scene, true, networkManager);
sceneManager.ScenesLoaded.Add(scene.handle, scene);
}
}
}
// Set the client synchronization mode
sceneManager.ClientSynchronizationMode = mode;
}
/// <summary>
/// During integration testing, if the server loads a scene then
/// we want to start tracking it.
/// </summary>
/// <param name="sceneEvent"></param>
private void SceneManager_OnSceneEvent(SceneEvent sceneEvent)
{
// Filter for server only scene events
if (!NetworkManager.IsServer || sceneEvent.ClientId != NetworkManager.ServerClientId)
{
return;
}
switch (sceneEvent.SceneEventType)
{
case SceneEventType.LoadComplete:
{
StartTrackingScene(sceneEvent.Scene, true, NetworkManager);
break;
}
}
}
/// <summary>
/// Handles determining if a client should attempt to load a scene during synchronization.
/// </summary>
/// <param name="sceneName">name of the scene to be loaded</param>
/// <param name="isPrimaryScene">when in client synchronization mode single, this determines if the scene is the primary active scene</param>
/// <param name="clientSynchronizationMode">the current client synchronization mode</param>
/// <param name="networkManager"><see cref="NetworkManager"/>relative instance</param>
/// <returns></returns>
public bool ClientShouldPassThrough(string sceneName, bool isPrimaryScene, LoadSceneMode clientSynchronizationMode, NetworkManager networkManager)
{
var shouldPassThrough = clientSynchronizationMode == LoadSceneMode.Single ? false : DoesSceneHaveUnassignedEntry(sceneName, networkManager);
var activeScene = SceneManager.GetActiveScene();
// If shouldPassThrough is not yet true and the scene to be loaded is the currently active scene
if (!shouldPassThrough && sceneName == activeScene.name)
{
// In additive client synchronization mode we always pass through.
// Unlike the default behavior(i.e. DefaultSceneManagerHandler), for integration testing we always return false
// if it is the active scene and the client synchronization mode is LoadSceneMode.Single because the client should
// load the active scene additively for this NetworkManager instance (i.e. can't have multiple active scenes).
if (clientSynchronizationMode == LoadSceneMode.Additive)
{
// don't try to reload this scene and pass through to post load processing.
shouldPassThrough = true;
}
}
return shouldPassThrough;
}
/// <summary>
/// Constructor now must take NetworkManager
/// </summary>
@@ -410,7 +941,11 @@ namespace Unity.Netcode.TestHelpers.Runtime
}
}
QueuedSceneJobs.Clear();
Object.Destroy(CoroutineRunner.gameObject);
if (CoroutineRunner != null && CoroutineRunner.gameObject != null)
{
Object.Destroy(CoroutineRunner.gameObject);
}
}
}
}

79
TestHelpers/Runtime/IntegrationTestWithApproximation.cs Normal file
View File

@@ -0,0 +1,79 @@
using System.Runtime.CompilerServices;
using UnityEngine;
namespace Unity.Netcode.TestHelpers.Runtime
{
public abstract class IntegrationTestWithApproximation : NetcodeIntegrationTest
{
private const float k_AproximateDeltaVariance = 0.01f;
protected virtual float GetDeltaVarianceThreshold()
{
return k_AproximateDeltaVariance;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
protected float EulerDelta(float a, float b)
{
return Mathf.DeltaAngle(a, b);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
protected Vector3 EulerDelta(Vector3 a, Vector3 b)
{
return new Vector3(Mathf.DeltaAngle(a.x, b.x), Mathf.DeltaAngle(a.y, b.y), Mathf.DeltaAngle(a.z, b.z));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
protected bool ApproximatelyEuler(float a, float b)
{
return Mathf.Abs(EulerDelta(a, b)) <= GetDeltaVarianceThreshold();
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
protected bool Approximately(float a, float b)
{
return Mathf.Abs(a - b) <= GetDeltaVarianceThreshold();
}
protected bool Approximately(Vector2 a, Vector2 b)
{
var deltaVariance = GetDeltaVarianceThreshold();
return Mathf.Abs(a.x - b.x) <= deltaVariance &&
Mathf.Abs(a.y - b.y) <= deltaVariance;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
protected bool Approximately(Vector3 a, Vector3 b)
{
var deltaVariance = GetDeltaVarianceThreshold();
return Mathf.Abs(a.x - b.x) <= deltaVariance &&
Mathf.Abs(a.y - b.y) <= deltaVariance &&
Mathf.Abs(a.z - b.z) <= deltaVariance;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
protected bool Approximately(Quaternion a, Quaternion b)
{
var deltaVariance = GetDeltaVarianceThreshold();
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;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
protected bool ApproximatelyEuler(Vector3 a, Vector3 b)
{
return ApproximatelyEuler(a.x, b.x) && ApproximatelyEuler(a.y, b.y) && ApproximatelyEuler(a.z, b.z);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
protected Vector3 GetRandomVector3(float min, float max)
{
return new Vector3(Random.Range(min, max), Random.Range(min, max), Random.Range(min, max));
}
}
}

11
TestHelpers/Runtime/IntegrationTestWithApproximation.cs.meta Normal file
View File

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

30
TestHelpers/Runtime/MockTimeProvider.cs Normal file
View File

@@ -0,0 +1,30 @@
namespace Unity.Netcode.TestHelpers.Runtime
{
public class MockTimeProvider : IRealTimeProvider
{
public float RealTimeSinceStartup => (float)s_DoubleRealTime;
public float UnscaledTime => (float)s_DoubleRealTime;
public float UnscaledDeltaTime => (float)s_DoubleDelta;
public float DeltaTime => (float)s_DoubleDelta;
public static float StaticRealTimeSinceStartup => (float)s_DoubleRealTime;
public static float StaticUnscaledTime => (float)s_DoubleRealTime;
public static float StaticUnscaledDeltaTime => (float)s_DoubleDelta;
public static float StaticDeltaTime => (float)s_DoubleDelta;
private static double s_DoubleRealTime = 0;
private static double s_DoubleDelta = 0;
public static void TimeTravel(double amountOfTimeTraveled)
{
s_DoubleDelta = amountOfTimeTraveled;
s_DoubleRealTime += amountOfTimeTraveled;
}
public static void Reset()
{
s_DoubleDelta = 0;
s_DoubleRealTime = 0;
}
}
}

3
TestHelpers/Runtime/MockTimeProvider.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: bcc9a7faadea4b8ebeb041ee6e395a92
timeCreated: 1679414015

89
TestHelpers/Runtime/MockTransport.cs Normal file
View File

@@ -0,0 +1,89 @@
using System;
using System.Collections.Generic;
namespace Unity.Netcode.TestHelpers.Runtime
{
internal class MockTransport : NetworkTransport
{
private struct MessageData
{
public ulong FromClientId;
public ArraySegment<byte> Payload;
public NetworkEvent Event;
}
private static Dictionary<ulong, Queue<MessageData>> s_MessageQueue = new Dictionary<ulong, Queue<MessageData>>();
public override ulong ServerClientId { get; } = 0;
public static ulong HighTransportId = 0;
public ulong TransportId = 0;
public NetworkManager NetworkManager;
public override void Send(ulong clientId, ArraySegment<byte> payload, NetworkDelivery networkDelivery)
{
var copy = new byte[payload.Array.Length];
Array.Copy(payload.Array, copy, payload.Array.Length);
s_MessageQueue[clientId].Enqueue(new MessageData { FromClientId = TransportId, Payload = new ArraySegment<byte>(copy, payload.Offset, payload.Count), Event = NetworkEvent.Data });
}
public override NetworkEvent PollEvent(out ulong clientId, out ArraySegment<byte> payload, out float receiveTime)
{
if (s_MessageQueue[TransportId].Count > 0)
{
var data = s_MessageQueue[TransportId].Dequeue();
clientId = data.FromClientId;
payload = data.Payload;
receiveTime = NetworkManager.RealTimeProvider.RealTimeSinceStartup;
if (NetworkManager.IsServer && data.Event == NetworkEvent.Connect)
{
s_MessageQueue[data.FromClientId].Enqueue(new MessageData { Event = NetworkEvent.Connect, FromClientId = ServerClientId, Payload = new ArraySegment<byte>() });
}
return data.Event;
}
clientId = 0;
payload = new ArraySegment<byte>();
receiveTime = 0;
return NetworkEvent.Nothing;
}
public override bool StartClient()
{
TransportId = ++HighTransportId;
s_MessageQueue[TransportId] = new Queue<MessageData>();
s_MessageQueue[ServerClientId].Enqueue(new MessageData { Event = NetworkEvent.Connect, FromClientId = TransportId, Payload = new ArraySegment<byte>() });
return true;
}
public override bool StartServer()
{
s_MessageQueue[ServerClientId] = new Queue<MessageData>();
return true;
}
public override void DisconnectRemoteClient(ulong clientId)
{
s_MessageQueue[clientId].Enqueue(new MessageData { Event = NetworkEvent.Disconnect, FromClientId = TransportId, Payload = new ArraySegment<byte>() });
}
public override void DisconnectLocalClient()
{
s_MessageQueue[ServerClientId].Enqueue(new MessageData { Event = NetworkEvent.Disconnect, FromClientId = TransportId, Payload = new ArraySegment<byte>() });
}
public override ulong GetCurrentRtt(ulong clientId)
{
return 0;
}
public override void Shutdown()
{
}
public override void Initialize(NetworkManager networkManager = null)
{
NetworkManager = networkManager;
}
}
}

3
TestHelpers/Runtime/MockTransport.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 335908e9a37f428ba087acf00563c7be
timeCreated: 1679415868

517
TestHelpers/Runtime/NetcodeIntegrationTest.cs
View File

@@ -2,12 +2,14 @@ using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using NUnit.Framework;
using Unity.Netcode.RuntimeTests;
using Unity.Netcode.Transports.UTP;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.TestTools;
using System.Runtime.CompilerServices;
using Unity.Netcode.RuntimeTests;
using Object = UnityEngine.Object;
namespace Unity.Netcode.TestHelpers.Runtime
@@ -22,6 +24,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// determine how clients will load scenes
/// </summary>
internal static bool IsRunning { get; private set; }
protected static TimeoutHelper s_GlobalTimeoutHelper = new TimeoutHelper(8.0f);
protected static WaitForSecondsRealtime s_DefaultWaitForTick = new WaitForSecondsRealtime(1.0f / k_DefaultTickRate);
@@ -44,6 +47,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
{
s_GlobalNetworkObjects.Add(networkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());
}
if (s_GlobalNetworkObjects[networkObject.NetworkManager.LocalClientId].ContainsKey(networkObject.NetworkObjectId))
{
if (s_GlobalNetworkObjects[networkObject.NetworkManager.LocalClientId] == null)
@@ -100,9 +104,9 @@ namespace Unity.Netcode.TestHelpers.Runtime
public enum NetworkManagerInstatiationMode
{
PerTest, // This will create and destroy new NetworkManagers for each test within a child derived class
AllTests, // This will create one set of NetworkManagers used for all tests within a child derived class (destroyed once all tests are finished)
DoNotCreate // This will not create any NetworkManagers, it is up to the derived class to manage.
PerTest, // This will create and destroy new NetworkManagers for each test within a child derived class
AllTests, // This will create one set of NetworkManagers used for all tests within a child derived class (destroyed once all tests are finished)
DoNotCreate // This will not create any NetworkManagers, it is up to the derived class to manage.
}
public enum HostOrServer
@@ -143,6 +147,75 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// </remarks>
protected bool m_BypassConnectionTimeout { get; set; }
/// <summary>
/// Enables "Time Travel" within the test, which swaps the time provider for the SDK from Unity's
/// <see cref="Time"/> class to <see cref="MockTimeProvider"/>, and also swaps the transport implementation
/// from <see cref="UnityTransport"/> to <see cref="MockTransport"/>.
///
/// This enables five important things that help with both performance and determinism of tests that involve a
/// lot of time and waiting:
/// 1) It allows time to move in a completely deterministic way (testing that something happens after n seconds,
/// the test will always move exactly n seconds with no chance of any variability in the timing),
/// 2) It allows skipping periods of time without actually waiting that amount of time, while still simulating
/// SDK frames as if that time were passing,
/// 3) It dissociates the SDK's update loop from Unity's update loop, allowing us to simulate SDK frame updates
/// without waiting for Unity to process things like physics, animation, and rendering that aren't relevant to
/// the test,
/// 4) It dissociates the SDK's messaging system from the networking hardware, meaning there's no delay between
/// a message being sent and it being received, allowing us to deterministically rely on the message being
/// received within specific time frames for the test, and
/// 5) It allows tests to be written without the use of coroutines, which not only improves the test's runtime,
/// but also results in easier-to-read callstacks and removes the possibility for an assertion to result in the
/// test hanging.
///
/// When time travel is enabled, the following methods become available:
///
/// <see cref="TimeTravel"/>: Simulates a specific number of frames passing over a specific time period
/// <see cref="TimeTravelToNextTick"/>: Skips forward to the next tick, siumlating at the current application frame rate
/// <see cref="WaitForConditionOrTimeOutWithTimeTravel(Func{bool},int)"/>: Simulates frames at the application frame rate until the given condition is true
/// <see cref="WaitForMessageReceivedWithTimeTravel{T}"/>: Simulates frames at the application frame rate until the required message is received
/// <see cref="WaitForMessagesReceivedWithTimeTravel"/>: Simulates frames at the application frame rate until the required messages are received
/// <see cref="StartServerAndClientsWithTimeTravel"/>: Starts a server and client and allows them to connect via simulated frames
/// <see cref="CreateAndStartNewClientWithTimeTravel"/>: Creates a client and waits for it to connect via simulated frames
/// <see cref="WaitForClientsConnectedOrTimeOutWithTimeTravel(Unity.Netcode.NetworkManager[])"/> Simulates frames at the application frame rate until the given clients are connected
/// <see cref="StopOneClientWithTimeTravel"/>: Stops a client and simulates frames until it's fully disconnected.
///
/// When time travel is enabled, <see cref="NetcodeIntegrationTest"/> will automatically use these in its methods
/// when doing things like automatically connecting clients during SetUp.
///
/// Additionally, the following methods replace their non-time-travel equivalents with variants that are not coroutines:
/// <see cref="OnTimeTravelStartedServerAndClients"/> - called when server and clients are started
/// <see cref="OnTimeTravelServerAndClientsConnected"/> - called when server and clients are connected
///
/// Note that all of the non-time travel functions can still be used even when time travel is enabled - this is
/// sometimes needed for, e.g., testing NetworkAnimator, where the unity update loop needs to run to process animations.
/// However, it's VERY important to note here that, because the SDK will not be operating based on real-world time
/// but based on the frozen time that's locked in from MockTimeProvider, actions that pass 10 seconds apart by
/// real-world clock time will be perceived by the SDK as having happened simultaneously if you don't call
/// <see cref="MockTimeProvider.TimeTravel"/> to cover the equivalent time span in the mock time provider.
/// (Calling <see cref="MockTimeProvider.TimeTravel"/> instead of <see cref="TimeTravel"/>
/// will move time forward without simulating any frames, which, in the case where real-world time has passed,
/// is likely more desirable). In most cases, this desynch won't affect anything, but it is worth noting that
/// it happens just in case a tested system depends on both the unity update loop happening *and* time moving forward.
/// </summary>
protected virtual bool m_EnableTimeTravel => false;
/// <summary>
/// If this is false, SetUp will call OnInlineSetUp instead of OnSetUp.
/// This is a performance advantage when not using the coroutine functionality, as a coroutine that
/// has no yield instructions in it will nonetheless still result in delaying the continuation of the
/// method that called it for a full frame after it returns.
/// </summary>
protected virtual bool m_SetupIsACoroutine => true;
/// <summary>
/// If this is false, TearDown will call OnInlineTearDown instead of OnTearDown.
/// This is a performance advantage when not using the coroutine functionality, as a coroutine that
/// has no yield instructions in it will nonetheless still result in delaying the continuation of the
/// method that called it for a full frame after it returns.
/// </summary>
protected virtual bool m_TearDownIsACoroutine => true;
/// <summary>
/// Used to display the various integration test
/// stages and can be used to log verbose information
@@ -216,20 +289,54 @@ namespace Unity.Netcode.TestHelpers.Runtime
yield return null;
}
/// <summary>
/// Called before creating and starting the server and clients
/// Note: For <see cref="NetworkManagerInstatiationMode.AllTests"/> and
/// <see cref="NetworkManagerInstatiationMode.PerTest"/> mode integration tests.
/// For those two modes, if you want to have access to the server or client
/// <see cref="NetworkManager"/>s then override <see cref="OnServerAndClientsCreated"/>.
/// <see cref="m_ServerNetworkManager"/> and <see cref="m_ClientNetworkManagers"/>
/// </summary>
protected virtual void OnInlineSetup()
{
}
[UnitySetUp]
public IEnumerator SetUp()
{
VerboseDebug($"Entering {nameof(SetUp)}");
NetcodeLogAssert = new NetcodeLogAssert();
yield return OnSetup();
if (m_SetupIsACoroutine)
{
yield return OnSetup();
}
else
{
OnInlineSetup();
}
if (m_EnableTimeTravel)
{
MockTimeProvider.Reset();
ComponentFactory.Register<IRealTimeProvider>(manager => new MockTimeProvider());
}
if (m_NetworkManagerInstatiationMode == NetworkManagerInstatiationMode.AllTests && m_ServerNetworkManager == null ||
m_NetworkManagerInstatiationMode == NetworkManagerInstatiationMode.PerTest)
{
CreateServerAndClients();
yield return StartServerAndClients();
if (m_EnableTimeTravel)
{
StartServerAndClientsWithTimeTravel();
}
else
{
yield return StartServerAndClients();
}
}
VerboseDebug($"Exiting {nameof(SetUp)}");
}
@@ -294,6 +401,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
{
clientNetworkManagersList.Remove(networkManager);
}
m_ClientNetworkManagers = clientNetworkManagersList.ToArray();
m_NumberOfClients = clientNetworkManagersList.Count;
}
@@ -304,7 +412,6 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// </summary>
protected virtual void OnNewClientCreated(NetworkManager networkManager)
{
}
/// <summary>
@@ -322,7 +429,6 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// </summary>
protected virtual void OnNewClientStartedAndConnected(NetworkManager networkManager)
{
}
/// <summary>
@@ -331,7 +437,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// </summary>
protected IEnumerator CreateAndStartNewClient()
{
var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length);
var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_EnableTimeTravel);
networkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab;
// Notification that the new client (NetworkManager) has been created
@@ -356,13 +462,53 @@ namespace Unity.Netcode.TestHelpers.Runtime
if (s_GlobalTimeoutHelper.TimedOut)
{
AddRemoveNetworkManager(networkManager, false);
Object.Destroy(networkManager.gameObject);
Object.DestroyImmediate(networkManager.gameObject);
}
AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for the new client to be connected!");
ClientNetworkManagerPostStart(networkManager);
VerboseDebug($"[{networkManager.name}] Created and connected!");
}
/// <summary>
/// This will create, start, and connect a new client while in the middle of an
/// integration test.
/// </summary>
protected void CreateAndStartNewClientWithTimeTravel()
{
var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_EnableTimeTravel);
networkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab;
// Notification that the new client (NetworkManager) has been created
// in the event any modifications need to be made before starting the client
OnNewClientCreated(networkManager);
NetcodeIntegrationTestHelpers.StartOneClient(networkManager);
if (LogAllMessages)
{
networkManager.MessagingSystem.Hook(new DebugNetworkHooks());
}
AddRemoveNetworkManager(networkManager, true);
OnNewClientStarted(networkManager);
// Wait for the new client to connect
var connected = WaitForClientsConnectedOrTimeOutWithTimeTravel();
OnNewClientStartedAndConnected(networkManager);
if (!connected)
{
AddRemoveNetworkManager(networkManager, false);
Object.DestroyImmediate(networkManager.gameObject);
}
Assert.IsTrue(connected, $"{nameof(CreateAndStartNewClient)} timed out waiting for the new client to be connected!");
ClientNetworkManagerPostStart(networkManager);
VerboseDebug($"[{networkManager.name}] Created and connected!");
}
/// <summary>
/// This will stop a client while in the middle of an integration test
/// </summary>
@@ -373,6 +519,16 @@ namespace Unity.Netcode.TestHelpers.Runtime
yield return WaitForConditionOrTimeOut(() => !networkManager.IsConnectedClient);
}
/// <summary>
/// This will stop a client while in the middle of an integration test
/// </summary>
protected void StopOneClientWithTimeTravel(NetworkManager networkManager, bool destroy = false)
{
NetcodeIntegrationTestHelpers.StopOneClient(networkManager, destroy);
AddRemoveNetworkManager(networkManager, false);
Assert.True(WaitForConditionOrTimeOutWithTimeTravel(() => !networkManager.IsConnectedClient));
}
/// <summary>
/// Creates the server and clients
/// </summary>
@@ -383,8 +539,13 @@ namespace Unity.Netcode.TestHelpers.Runtime
CreatePlayerPrefab();
if (m_EnableTimeTravel)
{
m_TargetFrameRate = -1;
}
// Create multiple NetworkManager instances
if (!NetcodeIntegrationTestHelpers.Create(numberOfClients, out NetworkManager server, out NetworkManager[] clients, m_TargetFrameRate, m_CreateServerFirst))
if (!NetcodeIntegrationTestHelpers.Create(numberOfClients, out NetworkManager server, out NetworkManager[] clients, m_TargetFrameRate, m_CreateServerFirst, m_EnableTimeTravel))
{
Debug.LogError("Failed to create instances");
Assert.Fail("Failed to create instances");
@@ -431,6 +592,14 @@ namespace Unity.Netcode.TestHelpers.Runtime
yield return null;
}
/// <summary>
/// Invoked after the server and clients have started.
/// Note: No connection verification has been done at this point
/// </summary>
protected virtual void OnTimeTravelStartedServerAndClients()
{
}
/// <summary>
/// Invoked after the server and clients have started and verified
/// their connections with each other.
@@ -440,6 +609,14 @@ namespace Unity.Netcode.TestHelpers.Runtime
yield return null;
}
/// <summary>
/// Invoked after the server and clients have started and verified
/// their connections with each other.
/// </summary>
protected virtual void OnTimeTravelServerAndClientsConnected()
{
}
private void ClientNetworkManagerPostStart(NetworkManager networkManager)
{
networkManager.name = $"NetworkManager - Client - {networkManager.LocalClientId}";
@@ -466,6 +643,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
{
m_PlayerNetworkObjects.Add(playerNetworkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());
}
if (!m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].ContainsKey(networkManager.LocalClientId))
{
m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(networkManager.LocalClientId, playerNetworkObject);
@@ -495,6 +673,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
{
ClientNetworkManagerPostStart(networkManager);
}
if (m_UseHost)
{
#if UNITY_2023_1_OR_NEWER
@@ -509,6 +688,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
{
m_PlayerNetworkObjects.Add(playerNetworkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());
}
if (!m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].ContainsKey(m_ServerNetworkManager.LocalClientId))
{
m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(m_ServerNetworkManager.LocalClientId, playerNetworkObject);
@@ -570,6 +750,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
{
m_PlayerNetworkObjects.Add(playerNetworkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());
}
m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(m_ServerNetworkManager.LocalClientId, playerNetworkObject);
}
}
@@ -585,6 +766,73 @@ namespace Unity.Netcode.TestHelpers.Runtime
}
}
/// <summary>
/// This starts the server and clients as long as <see cref="CanStartServerAndClients"/>
/// returns true.
/// </summary>
protected void StartServerAndClientsWithTimeTravel()
{
if (CanStartServerAndClients())
{
VerboseDebug($"Entering {nameof(StartServerAndClientsWithTimeTravel)}");
// Start the instances and pass in our SceneManagerInitialization action that is invoked immediately after host-server
// is started and after each client is started.
if (!NetcodeIntegrationTestHelpers.Start(m_UseHost, m_ServerNetworkManager, m_ClientNetworkManagers))
{
Debug.LogError("Failed to start instances");
Assert.Fail("Failed to start instances");
}
if (LogAllMessages)
{
EnableMessageLogging();
}
RegisterSceneManagerHandler();
// Notification that the server and clients have been started
OnTimeTravelStartedServerAndClients();
// When true, we skip everything else (most likely a connection oriented test)
if (!m_BypassConnectionTimeout)
{
// Wait for all clients to connect
WaitForClientsConnectedOrTimeOutWithTimeTravel();
AssertOnTimeout($"{nameof(StartServerAndClients)} timed out waiting for all clients to be connected!");
if (m_UseHost || m_ServerNetworkManager.IsHost)
{
#if UNITY_2023_1_OR_NEWER
// Add the server player instance to all m_ClientSidePlayerNetworkObjects entries
var serverPlayerClones = Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.None).Where((c) => c.IsPlayerObject && c.OwnerClientId == m_ServerNetworkManager.LocalClientId);
#else
// Add the server player instance to all m_ClientSidePlayerNetworkObjects entries
var serverPlayerClones = Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsPlayerObject && c.OwnerClientId == m_ServerNetworkManager.LocalClientId);
#endif
foreach (var playerNetworkObject in serverPlayerClones)
{
if (!m_PlayerNetworkObjects.ContainsKey(playerNetworkObject.NetworkManager.LocalClientId))
{
m_PlayerNetworkObjects.Add(playerNetworkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());
}
m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(m_ServerNetworkManager.LocalClientId, playerNetworkObject);
}
}
ClientNetworkManagerPostStartInit();
// Notification that at this time the server and client(s) are instantiated,
// started, and connected on both sides.
OnTimeTravelServerAndClientsConnected();
VerboseDebug($"Exiting {nameof(StartServerAndClients)}");
}
}
}
/// <summary>
/// Override this method to control when clients
/// can fake-load a scene.
@@ -660,12 +908,15 @@ namespace Unity.Netcode.TestHelpers.Runtime
m_PlayerNetworkObjects.Clear();
s_GlobalNetworkObjects.Clear();
}
catch (Exception e) { throw e; }
catch (Exception e)
{
throw e;
}
finally
{
if (m_PlayerPrefab != null)
{
Object.Destroy(m_PlayerPrefab);
Object.DestroyImmediate(m_PlayerPrefab);
m_PlayerPrefab = null;
}
}
@@ -689,17 +940,34 @@ namespace Unity.Netcode.TestHelpers.Runtime
yield return null;
}
protected virtual void OnInlineTearDown()
{
}
[UnityTearDown]
public IEnumerator TearDown()
{
IntegrationTestSceneHandler.SceneNameToSceneHandles.Clear();
VerboseDebug($"Entering {nameof(TearDown)}");
yield return OnTearDown();
if (m_TearDownIsACoroutine)
{
yield return OnTearDown();
}
else
{
OnInlineTearDown();
}
if (m_NetworkManagerInstatiationMode == NetworkManagerInstatiationMode.PerTest)
{
ShutdownAndCleanUp();
}
if (m_EnableTimeTravel)
{
ComponentFactory.Deregister<IRealTimeProvider>();
}
VerboseDebug($"Exiting {nameof(TearDown)}");
LogWaitForMessages();
NetcodeLogAssert.Dispose();
@@ -773,6 +1041,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
{
continue;
}
if (CanDestroyNetworkObject(networkObject))
{
networkObject.NetworkManagerOwner = m_ServerNetworkManager;
@@ -831,10 +1100,49 @@ namespace Unity.Netcode.TestHelpers.Runtime
// Otherwise wait for 1 tick interval
yield return s_DefaultWaitForTick;
}
// Stop checking for a timeout
timeOutHelper.Stop();
}
/// <summary>
/// Waits for the function condition to return true or it will time out. Uses time travel to simulate this
/// for the given number of frames, simulating delta times at the application frame rate.
/// </summary>
public bool WaitForConditionOrTimeOutWithTimeTravel(Func<bool> checkForCondition, int maxTries = 60)
{
if (checkForCondition == null)
{
throw new ArgumentNullException($"checkForCondition cannot be null!");
}
if (!m_EnableTimeTravel)
{
throw new ArgumentException($"Time travel must be enabled to use {nameof(WaitForConditionOrTimeOutWithTimeTravel)}!");
}
var frameRate = Application.targetFrameRate;
if (frameRate <= 0)
{
frameRate = 60;
}
var updateInterval = 1f / frameRate;
for (var i = 0; i < maxTries; ++i)
{
// Simulate a frame passing on all network managers
TimeTravel(updateInterval, 1);
// Update and check to see if the condition has been met
if (checkForCondition.Invoke())
{
return true;
}
}
return false;
}
/// <summary>
/// This version accepts an IConditionalPredicate implementation to provide
/// more flexibility for checking complex conditional cases.
@@ -857,6 +1165,29 @@ namespace Unity.Netcode.TestHelpers.Runtime
conditionalPredicate.Finished(timeOutHelper.TimedOut);
}
/// <summary>
/// This version accepts an IConditionalPredicate implementation to provide
/// more flexibility for checking complex conditional cases. Uses time travel to simulate this
/// for the given number of frames, simulating delta times at the application frame rate.
/// </summary>
public bool WaitForConditionOrTimeOutWithTimeTravel(IConditionalPredicate conditionalPredicate, int maxTries = 60)
{
if (conditionalPredicate == null)
{
throw new ArgumentNullException($"checkForCondition cannot be null!");
}
if (!m_EnableTimeTravel)
{
throw new ArgumentException($"Time travel must be enabled to use {nameof(WaitForConditionOrTimeOutWithTimeTravel)}!");
}
conditionalPredicate.Started();
var success = WaitForConditionOrTimeOutWithTimeTravel(conditionalPredicate.HasConditionBeenReached, maxTries);
conditionalPredicate.Finished(!success);
return success;
}
/// <summary>
/// Validates that all remote clients (i.e. non-server) detect they are connected
/// to the server and that the server reflects the appropriate number of clients
@@ -869,7 +1200,23 @@ namespace Unity.Netcode.TestHelpers.Runtime
var serverClientCount = m_ServerNetworkManager.IsHost ? remoteClientCount + 1 : remoteClientCount;
yield return WaitForConditionOrTimeOut(() => clientsToCheck.Where((c) => c.IsConnectedClient).Count() == remoteClientCount &&
m_ServerNetworkManager.ConnectedClients.Count == serverClientCount);
m_ServerNetworkManager.ConnectedClients.Count == serverClientCount);
}
/// <summary>
/// Validates that all remote clients (i.e. non-server) detect they are connected
/// to the server and that the server reflects the appropriate number of clients
/// have connected or it will time out. Uses time travel to simulate this
/// for the given number of frames, simulating delta times at the application frame rate.
/// </summary>
/// <param name="clientsToCheck">An array of clients to be checked</param>
protected bool WaitForClientsConnectedOrTimeOutWithTimeTravel(NetworkManager[] clientsToCheck)
{
var remoteClientCount = clientsToCheck.Length;
var serverClientCount = m_ServerNetworkManager.IsHost ? remoteClientCount + 1 : remoteClientCount;
return WaitForConditionOrTimeOutWithTimeTravel(() => clientsToCheck.Where((c) => c.IsConnectedClient).Count() == remoteClientCount &&
m_ServerNetworkManager.ConnectedClients.Count == serverClientCount);
}
/// <summary>
@@ -881,6 +1228,16 @@ namespace Unity.Netcode.TestHelpers.Runtime
yield return WaitForClientsConnectedOrTimeOut(m_ClientNetworkManagers);
}
/// <summary>
/// Overloaded method that just passes in all clients to
/// <see cref="WaitForClientsConnectedOrTimeOut(NetworkManager[])"/> Uses time travel to simulate this
/// for the given number of frames, simulating delta times at the application frame rate.
/// </summary>
protected bool WaitForClientsConnectedOrTimeOutWithTimeTravel()
{
return WaitForClientsConnectedOrTimeOutWithTimeTravel(m_ClientNetworkManagers);
}
internal IEnumerator WaitForMessageReceived<T>(List<NetworkManager> wiatForReceivedBy, ReceiptType type = ReceiptType.Handled) where T : INetworkMessage
{
// Build our message hook entries tables so we can determine if all clients received spawn or ownership messages
@@ -891,17 +1248,18 @@ namespace Unity.Netcode.TestHelpers.Runtime
messageHook.AssignMessageType<T>();
messageHookEntriesForSpawn.Add(messageHook);
}
// Used to determine if all clients received the CreateObjectMessage
var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
yield return WaitForConditionOrTimeOut(hooks);
Assert.False(s_GlobalTimeoutHelper.TimedOut);
}
internal IEnumerator WaitForMessagesReceived(List<Type> messagesInOrder, List<NetworkManager> wiatForReceivedBy, ReceiptType type = ReceiptType.Handled)
internal IEnumerator WaitForMessagesReceived(List<Type> messagesInOrder, List<NetworkManager> waitForReceivedBy, ReceiptType type = ReceiptType.Handled)
{
// Build our message hook entries tables so we can determine if all clients received spawn or ownership messages
var messageHookEntriesForSpawn = new List<MessageHookEntry>();
foreach (var clientNetworkManager in wiatForReceivedBy)
foreach (var clientNetworkManager in waitForReceivedBy)
{
foreach (var message in messagesInOrder)
{
@@ -910,12 +1268,49 @@ namespace Unity.Netcode.TestHelpers.Runtime
messageHookEntriesForSpawn.Add(messageHook);
}
}
// Used to determine if all clients received the CreateObjectMessage
var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
yield return WaitForConditionOrTimeOut(hooks);
Assert.False(s_GlobalTimeoutHelper.TimedOut);
}
internal void WaitForMessageReceivedWithTimeTravel<T>(List<NetworkManager> waitForReceivedBy, ReceiptType type = ReceiptType.Handled) where T : INetworkMessage
{
// Build our message hook entries tables so we can determine if all clients received spawn or ownership messages
var messageHookEntriesForSpawn = new List<MessageHookEntry>();
foreach (var clientNetworkManager in waitForReceivedBy)
{
var messageHook = new MessageHookEntry(clientNetworkManager, type);
messageHook.AssignMessageType<T>();
messageHookEntriesForSpawn.Add(messageHook);
}
// Used to determine if all clients received the CreateObjectMessage
var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
Assert.True(WaitForConditionOrTimeOutWithTimeTravel(hooks));
}
internal void WaitForMessagesReceivedWithTimeTravel(List<Type> messagesInOrder, List<NetworkManager> waitForReceivedBy, ReceiptType type = ReceiptType.Handled)
{
// Build our message hook entries tables so we can determine if all clients received spawn or ownership messages
var messageHookEntriesForSpawn = new List<MessageHookEntry>();
foreach (var clientNetworkManager in waitForReceivedBy)
{
foreach (var message in messagesInOrder)
{
var messageHook = new MessageHookEntry(clientNetworkManager, type);
messageHook.AssignMessageType(message);
messageHookEntriesForSpawn.Add(messageHook);
}
}
// Used to determine if all clients received the CreateObjectMessage
var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
Assert.True(WaitForConditionOrTimeOutWithTimeTravel(hooks));
}
/// <summary>
/// Creates a basic NetworkObject test prefab, assigns it to a new
/// NetworkPrefab entry, and then adds it to the server and client(s)
@@ -926,7 +1321,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
protected GameObject CreateNetworkObjectPrefab(string baseName)
{
var prefabCreateAssertError = $"You can only invoke this method during {nameof(OnServerAndClientsCreated)} " +
$"but before {nameof(OnStartedServerAndClients)}!";
$"but before {nameof(OnStartedServerAndClients)}!";
Assert.IsNotNull(m_ServerNetworkManager, prefabCreateAssertError);
Assert.IsFalse(m_ServerNetworkManager.IsListening, prefabCreateAssertError);
@@ -1000,6 +1395,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
{
gameObjectsSpawned.Add(SpawnObject(prefabNetworkObject, owner, destroyWithScene));
}
return gameObjectsSpawned;
}
@@ -1008,7 +1404,6 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// </summary>
public NetcodeIntegrationTest()
{
}
/// <summary>
@@ -1038,7 +1433,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// </summary>
protected void AssertOnTimeout(string timeOutErrorMessage, TimeoutHelper assignedTimeoutHelper = null)
{
var timeoutHelper = assignedTimeoutHelper != null ? assignedTimeoutHelper : s_GlobalTimeoutHelper;
var timeoutHelper = assignedTimeoutHelper ?? s_GlobalTimeoutHelper;
Assert.False(timeoutHelper.TimedOut, timeOutErrorMessage);
}
@@ -1054,6 +1449,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
{
continue;
}
VerboseDebug($"Unloading scene {scene.name}-{scene.handle}");
var asyncOperation = SceneManager.UnloadSceneAsync(scene);
}
@@ -1093,6 +1489,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
}
}
}
m_WaitForLog.Append($"[NetworkManager-{networkManager.LocalClientId}][WaitForTicks-End] Waited for ({networkManager.NetworkTickSystem.LocalTime.Tick - tickStart}) network ticks and ({frameCount}) frames to pass.\n");
yield break;
}
@@ -1114,5 +1511,83 @@ namespace Unity.Netcode.TestHelpers.Runtime
m_WaitForLog.Append($"[NetworkManager-{networkManager.LocalClientId}][WaitForTicks] TickRate ({networkManager.NetworkConfig.TickRate}) | Tick Wait ({count}) | TargetFrameRate ({Application.targetFrameRate}) | Target Frames ({framesPerTick * count})\n");
yield return WaitForTickAndFrames(networkManager, count, totalFrameCount);
}
/// <summary>
/// Simulate a number of frames passing over a specific amount of time.
/// The delta time simulated for each frame will be evenly divided as time/numFrames
/// This will only simulate the netcode update loop, as well as update events on
/// NetworkBehaviour instances, and will not simulate any Unity update processes (physics, etc)
/// </summary>
/// <param name="amountOfTimeInSeconds"></param>
/// <param name="numFramesToSimulate"></param>
protected static void TimeTravel(double amountOfTimeInSeconds, int numFramesToSimulate)
{
var interval = amountOfTimeInSeconds / numFramesToSimulate;
for (var i = 0; i < numFramesToSimulate; ++i)
{
MockTimeProvider.TimeTravel(interval);
SimulateOneFrame();
}
}
/// <summary>
/// Helper function to time travel exactly one tick's worth of time at the current frame and tick rates.
/// </summary>
public static void TimeTravelToNextTick()
{
var timePassed = 1.0f / k_DefaultTickRate;
var frameRate = Application.targetFrameRate;
if (frameRate <= 0)
{
frameRate = 60;
}
var frames = Math.Max((int)(timePassed / frameRate), 1);
TimeTravel(timePassed, frames);
}
/// <summary>
/// Simulates one SDK frame. This can be used even without TimeTravel, though it's of somewhat less use
/// without TimeTravel, as, without the mock transport, it will likely not provide enough time for any
/// sent messages to be received even if called dozens of times.
/// </summary>
public static void SimulateOneFrame()
{
foreach (NetworkUpdateStage stage in Enum.GetValues(typeof(NetworkUpdateStage)))
{
NetworkUpdateLoop.RunNetworkUpdateStage(stage);
string methodName = string.Empty;
switch (stage)
{
case NetworkUpdateStage.FixedUpdate:
methodName = "FixedUpdate"; // mapping NetworkUpdateStage.FixedUpdate to MonoBehaviour.FixedUpdate
break;
case NetworkUpdateStage.Update:
methodName = "Update"; // mapping NetworkUpdateStage.Update to MonoBehaviour.Update
break;
case NetworkUpdateStage.PreLateUpdate:
methodName = "LateUpdate"; // mapping NetworkUpdateStage.PreLateUpdate to MonoBehaviour.LateUpdate
break;
}
if (!string.IsNullOrEmpty(methodName))
{
#if UNITY_2023_1_OR_NEWER
foreach (var behaviour in Object.FindObjectsByType<NetworkBehaviour>(FindObjectsSortMode.InstanceID))
#else
foreach (var behaviour in Object.FindObjectsOfType<NetworkBehaviour>())
#endif
{
var method = behaviour.GetType().GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);
if (method == null)
{
method = behaviour.GetType().GetMethod(methodName, BindingFlags.Public | BindingFlags.Instance);
}
method?.Invoke(behaviour, new object[] { });
}
}
}
}
}
}

102
TestHelpers/Runtime/NetcodeIntegrationTestHelpers.cs
View File

@@ -186,7 +186,16 @@ namespace Unity.Netcode.TestHelpers.Runtime
networkManager.NetworkConfig.NetworkTransport = unityTransport;
}
public static NetworkManager CreateServer()
private static void AddMockTransport(NetworkManager networkManager)
{
// Create transport
var mockTransport = networkManager.gameObject.AddComponent<MockTransport>();
// Set the NetworkConfig
networkManager.NetworkConfig ??= new NetworkConfig();
networkManager.NetworkConfig.NetworkTransport = mockTransport;
}
public static NetworkManager CreateServer(bool mockTransport = false)
{
// Create gameObject
var go = new GameObject("NetworkManager - Server");
@@ -194,7 +203,14 @@ namespace Unity.Netcode.TestHelpers.Runtime
// Create networkManager component
var server = go.AddComponent<NetworkManager>();
NetworkManagerInstances.Insert(0, server);
AddUnityTransport(server);
if (mockTransport)
{
AddMockTransport(server);
}
else
{
AddUnityTransport(server);
}
return server;
}
@@ -206,20 +222,20 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// <param name="clients">The clients NetworkManagers</param>
/// <param name="targetFrameRate">The targetFrameRate of the Unity engine to use while the multi instance helper is running. Will be reset on shutdown.</param>
/// <param name="serverFirst">This determines if the server or clients will be instantiated first (defaults to server first)</param>
public static bool Create(int clientCount, out NetworkManager server, out NetworkManager[] clients, int targetFrameRate = 60, bool serverFirst = true)
public static bool Create(int clientCount, out NetworkManager server, out NetworkManager[] clients, int targetFrameRate = 60, bool serverFirst = true, bool useMockTransport = false)
{
s_NetworkManagerInstances = new List<NetworkManager>();
server = null;
if (serverFirst)
{
server = CreateServer();
server = CreateServer(useMockTransport);
}
CreateNewClients(clientCount, out clients);
CreateNewClients(clientCount, out clients, useMockTransport);
if (!serverFirst)
{
server = CreateServer();
server = CreateServer(useMockTransport);
}
s_OriginalTargetFrameRate = Application.targetFrameRate;
@@ -228,13 +244,20 @@ namespace Unity.Netcode.TestHelpers.Runtime
return true;
}
internal static NetworkManager CreateNewClient(int identifier)
internal static NetworkManager CreateNewClient(int identifier, bool mockTransport = false)
{
// Create gameObject
var go = new GameObject("NetworkManager - Client - " + identifier);
// Create networkManager component
var networkManager = go.AddComponent<NetworkManager>();
AddUnityTransport(networkManager);
if (mockTransport)
{
AddMockTransport(networkManager);
}
else
{
AddUnityTransport(networkManager);
}
return networkManager;
}
@@ -244,13 +267,13 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// </summary>
/// <param name="clientCount">The amount of clients</param>
/// <param name="clients"></param>
public static bool CreateNewClients(int clientCount, out NetworkManager[] clients)
public static bool CreateNewClients(int clientCount, out NetworkManager[] clients, bool useMockTransport = false)
{
clients = new NetworkManager[clientCount];
for (int i = 0; i < clientCount; i++)
{
// Create networkManager component
clients[i] = CreateNewClient(i);
clients[i] = CreateNewClient(i, useMockTransport);
}
NetworkManagerInstances.AddRange(clients);
@@ -314,7 +337,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
{
if (networkManager.gameObject != null)
{
Object.Destroy(networkManager.gameObject);
Object.DestroyImmediate(networkManager.gameObject);
}
}
@@ -339,6 +362,12 @@ namespace Unity.Netcode.TestHelpers.Runtime
return true;
}
private static bool VerifySceneIsValidForClientsToUnload(Scene scene)
{
// Unless specifically set, we always return false
return false;
}
/// <summary>
/// This registers scene validation callback for the server to prevent it from telling connecting
/// clients to synchronize (i.e. load) the test runner scene. This will also register the test runner
@@ -351,10 +380,21 @@ namespace Unity.Netcode.TestHelpers.Runtime
if (networkManager.IsServer && networkManager.SceneManager.VerifySceneBeforeLoading == null)
{
networkManager.SceneManager.VerifySceneBeforeLoading = VerifySceneIsValidForClientsToLoad;
// If a unit/integration test does not handle this on their own, then Ignore the validation warning
networkManager.SceneManager.DisableValidationWarnings(true);
}
// For testing purposes, all clients always set the VerifySceneBeforeUnloading callback and enabled
// PostSynchronizationSceneUnloading. Where tests that expect clients to unload scenes should override
// the callback and return true for the scenes the client(s) is/are allowed to unload.
if (!networkManager.IsServer && networkManager.SceneManager.VerifySceneBeforeUnloading == null)
{
networkManager.SceneManager.VerifySceneBeforeUnloading = VerifySceneIsValidForClientsToUnload;
networkManager.SceneManager.PostSynchronizationSceneUnloading = true;
}
// Register the test runner scene so it will be able to synchronize NetworkObjects without logging a
// warning about using the currently active scene
var scene = SceneManager.GetActiveScene();
@@ -494,8 +534,10 @@ namespace Unity.Netcode.TestHelpers.Runtime
Assert.IsNotNull(server, prefabCreateAssertError);
Assert.IsFalse(server.IsListening, prefabCreateAssertError);
var gameObject = new GameObject();
gameObject.name = baseName;
var gameObject = new GameObject
{
name = baseName
};
var networkObject = gameObject.AddComponent<NetworkObject>();
networkObject.NetworkManagerOwner = server;
MakeNetworkObjectTestPrefab(networkObject);
@@ -715,6 +757,40 @@ namespace Unity.Netcode.TestHelpers.Runtime
}
}
/// <summary>
/// Gets a NetworkObject instance as it's represented by a certain peer.
/// </summary>
/// <param name="predicate">The predicate used to filter for your target NetworkObject</param>
/// <param name="representation">The representation to get the object from</param>
/// <param name="result">The result</param>
/// <param name="failIfNull">Whether or not to fail if no object is found and result is null</param>
/// <param name="maxFrames">The max frames to wait for</param>
public static void GetNetworkObjectByRepresentationWithTimeTravel(Func<NetworkObject, bool> predicate, NetworkManager representation, ResultWrapper<NetworkObject> result, bool failIfNull = true, int maxTries = 60)
{
if (result == null)
{
throw new ArgumentNullException("Result cannot be null");
}
if (predicate == null)
{
throw new ArgumentNullException("Predicate cannot be null");
}
var tries = 0;
while (++tries < maxTries && !representation.SpawnManager.SpawnedObjects.Any(x => predicate(x.Value)))
{
NetcodeIntegrationTest.SimulateOneFrame();
}
result.Result = representation.SpawnManager.SpawnedObjects.FirstOrDefault(x => predicate(x.Value)).Value;
if (failIfNull && result.Result == null)
{
Assert.Fail("NetworkObject could not be found");
}
}
/// <summary>
/// Waits for a predicate condition to be met
/// </summary>

2
TestHelpers/Runtime/NetworkManagerHelper.cs
View File

@@ -1,8 +1,8 @@
using System;
using System.Collections.Generic;
using UnityEngine;
using NUnit.Framework;
using Unity.Netcode.Transports.UTP;
using UnityEngine;
namespace Unity.Netcode.TestHelpers.Runtime
{

109
TestHelpers/Runtime/TimeoutHelper.cs
View File

@@ -8,30 +8,67 @@ namespace Unity.Netcode.TestHelpers.Runtime
/// </summary>
public class TimeoutHelper
{
private const float k_DefaultTimeOutWaitPeriod = 2.0f;
protected const float k_DefaultTimeOutWaitPeriod = 2.0f;
private float m_MaximumTimeBeforeTimeOut;
private float m_TimeOutPeriod;
private bool m_IsStarted;
protected bool m_IsStarted { get; private set; }
public bool TimedOut { get; internal set; }
private float m_TimeStarted;
private float m_TimeStopped;
public float GetTimeElapsed()
{
if (m_IsStarted)
{
return Time.realtimeSinceStartup - m_TimeStarted;
}
else
{
return m_TimeStopped - m_TimeStarted;
}
}
protected virtual void OnStart()
{
}
public void Start()
{
m_TimeStopped = 0.0f;
m_TimeStarted = Time.realtimeSinceStartup;
m_MaximumTimeBeforeTimeOut = Time.realtimeSinceStartup + m_TimeOutPeriod;
m_IsStarted = true;
TimedOut = false;
OnStart();
}
protected virtual void OnStop()
{
}
public void Stop()
{
if (m_TimeStopped == 0.0f)
{
m_TimeStopped = Time.realtimeSinceStartup;
}
TimedOut = HasTimedOut();
m_IsStarted = false;
OnStop();
}
protected virtual bool OnHasTimedOut()
{
return m_IsStarted ? m_MaximumTimeBeforeTimeOut < Time.realtimeSinceStartup : TimedOut;
}
public bool HasTimedOut()
{
return m_IsStarted ? m_MaximumTimeBeforeTimeOut < Time.realtimeSinceStartup : TimedOut;
return OnHasTimedOut();
}
public TimeoutHelper(float timeOutPeriod = k_DefaultTimeOutWaitPeriod)
@@ -39,4 +76,70 @@ namespace Unity.Netcode.TestHelpers.Runtime
m_TimeOutPeriod = timeOutPeriod;
}
}
/// <summary>
/// This can be used in place of TimeoutHelper if you suspect a test is having
/// issues on a system where the frame rate is running slow than expected and
/// allowing a certain number of frame updates is required.
/// </summary>
public class TimeoutFrameCountHelper : TimeoutHelper
{
private const uint k_DefaultTickRate = 30;
private float m_TotalFramesToWait;
private int m_StartFrameCount;
private int m_EndFrameCount;
private bool m_ReachedFrameCount;
public int GetFrameCount()
{
if (m_IsStarted)
{
return Time.frameCount - m_StartFrameCount;
}
else
{
return m_EndFrameCount - m_StartFrameCount;
}
}
protected override void OnStop()
{
if (m_EndFrameCount == 0)
{
m_EndFrameCount = Time.frameCount;
}
base.OnStop();
}
protected override bool OnHasTimedOut()
{
var currentFrameCountDelta = Time.frameCount - m_StartFrameCount;
if (m_IsStarted)
{
m_ReachedFrameCount = currentFrameCountDelta >= m_TotalFramesToWait;
}
// Only time out if we have both exceeded the time period and the expected number of frames has reached the expected number of frames
// (this handles the scenario where some systems are running a much lower frame rate)
return m_ReachedFrameCount && base.OnHasTimedOut();
}
protected override void OnStart()
{
m_EndFrameCount = 0;
m_StartFrameCount = Time.frameCount;
base.OnStart();
}
public TimeoutFrameCountHelper(float timeOutPeriod = k_DefaultTimeOutWaitPeriod, uint tickRate = k_DefaultTickRate) : base(timeOutPeriod)
{
// Calculate the expected number of frame updates that should occur during the tick count wait period
var frameFrequency = 1.0f / (Application.targetFrameRate >= 60 && Application.targetFrameRate <= 100 ? Application.targetFrameRate : 60.0f);
var tickFrequency = 1.0f / tickRate;
var framesPerTick = tickFrequency / frameFrequency;
var totalExpectedTicks = timeOutPeriod / tickFrequency;
m_TotalFramesToWait = framesPerTick * totalExpectedTicks;
}
}
}