com.unity.netcode.gameobjects@1.5.1

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.5.1] - 2023-06-07

### Added

- Added support for serializing `NativeArray<>` and `NativeList<>` in `FastBufferReader`/`FastBufferWriter`, `BufferSerializer`, `NetworkVariable`, and RPCs. (To use `NativeList<>`, add `UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT` to your Scripting Define Symbols in `Project Settings > Player`) (#2375)
- The location of the automatically-created default network prefab list can now be configured (#2544)
- Added: Message size limits (max single message and max fragmented message) can now be set using NetworkManager.MaximumTransmissionUnitSize and NetworkManager.MaximumFragmentedMessageSize for transports that don't work with the default values (#2530)
- Added `NetworkObject.SpawnWithObservers` property (default is true) that when set to false will spawn a `NetworkObject` with no observers and will not be spawned on any client until `NetworkObject.NetworkShow` is invoked. (#2568)

### Fixed

- Fixed: Fixed a null reference in codegen in some projects (#2581)
- Fixed issue where the `OnClientDisconnected` client identifier was incorrect after a pending client connection was denied. (#2569)
- Fixed warning "Runtime Network Prefabs was not empty at initialization time." being erroneously logged when no runtime network prefabs had been added (#2565)
- Fixed issue where some temporary debug console logging was left in a merged PR. (#2562)
- Fixed the "Generate Default Network Prefabs List" setting not loading correctly and always reverting to being checked. (#2545)
- Fixed issue where users could not use NetworkSceneManager.VerifySceneBeforeLoading to exclude runtime generated scenes from client synchronization. (#2550)
- Fixed missing value on `NetworkListEvent` for `EventType.RemoveAt` events.  (#2542,#2543)
- Fixed issue where parenting a NetworkTransform under a transform with a scale other than Vector3.one would result in incorrect values on non-authoritative instances. (#2538)
- Fixed issue where a server would include scene migrated and then despawned NetworkObjects to a client that was being synchronized. (#2532)
- Fixed the inspector throwing exceptions when attempting to render `NetworkVariable`s of enum types. (#2529)
- Making a `NetworkVariable` with an `INetworkSerializable` type that doesn't meet the `new()` constraint will now create a compile-time error instead of an editor crash (#2528)
- Fixed Multiplayer Tools package installation docs page link on the NetworkManager popup. (#2526)
- Fixed an exception and error logging when two different objects are shown and hidden on the same frame (#2524)
- Fixed a memory leak in `UnityTransport` that occurred if `StartClient` failed. (#2518)
- Fixed issue where a client could throw an exception if abruptly disconnected from a network session with one or more spawned `NetworkObject`(s). (#2510)
- Fixed issue where invalid endpoint addresses were not being detected and returning false from NGO UnityTransport. (#2496)
- Fixed some errors that could occur if a connection is lost and the loss is detected when attempting to write to the socket. (#2495)

## Changed

- Adding network prefabs before NetworkManager initialization is now supported. (#2565)
- Connecting clients being synchronized now switch to the server's active scene before spawning and synchronizing NetworkObjects. (#2532)
- Updated `UnityTransport` dependency on `com.unity.transport` to 1.3.4. (#2533)
- Improved performance of NetworkBehaviour initialization by replacing reflection when initializing NetworkVariables with compile-time code generation, which should help reduce hitching during additive scene loads. (#2522)
This commit is contained in:
Unity Technologies
2023-06-07 00:00:00 +00:00
parent b5abc3ff7c
commit 4d70c198bd
119 changed files with 11328 additions and 3164 deletions

View File

@@ -2,111 +2,165 @@ using System.Collections;
using System.Linq;
using NUnit.Framework;
using Unity.Netcode.TestHelpers.Runtime;
using UnityEngine;
using UnityEngine.TestTools;
namespace Unity.Netcode.RuntimeTests
{
public class DisconnectTests
/// <summary>
/// Validates the client disconnection process.
/// This assures that:
/// - When a client disconnects from the server that the server:
/// -- Detects the client disconnected.
/// -- Cleans up the transport to NGO client (and vice versa) mappings.
/// - When a server disconnects a client that:
/// -- The client detects this disconnection.
/// -- The server cleans up the transport to NGO client (and vice versa) mappings.
/// - When <see cref="OwnerPersistence.DestroyWithOwner"/> the server-side player object is destroyed
/// - When <see cref="OwnerPersistence.DontDestroyWithOwner"/> the server-side player object ownership is transferred back to the server
/// </summary>
[TestFixture(OwnerPersistence.DestroyWithOwner)]
[TestFixture(OwnerPersistence.DontDestroyWithOwner)]
public class DisconnectTests : NetcodeIntegrationTest
{
private bool m_ClientDisconnected;
[UnityTest]
public IEnumerator RemoteDisconnectPlayerObjectCleanup()
public enum OwnerPersistence
{
// create server and client instances
NetcodeIntegrationTestHelpers.Create(1, out NetworkManager server, out NetworkManager[] clients);
// create prefab
var gameObject = new GameObject("PlayerObject");
var networkObject = gameObject.AddComponent<NetworkObject>();
networkObject.DontDestroyWithOwner = true;
NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(networkObject);
server.NetworkConfig.PlayerPrefab = gameObject;
for (int i = 0; i < clients.Length; i++)
{
clients[i].NetworkConfig.PlayerPrefab = gameObject;
}
// start server and connect clients
NetcodeIntegrationTestHelpers.Start(false, server, clients);
// wait for connection on client side
yield return NetcodeIntegrationTestHelpers.WaitForClientsConnected(clients);
// wait for connection on server side
yield return NetcodeIntegrationTestHelpers.WaitForClientConnectedToServer(server);
// disconnect the remote client
m_ClientDisconnected = false;
server.DisconnectClient(clients[0].LocalClientId);
clients[0].OnClientDisconnectCallback += OnClientDisconnectCallback;
var timeoutHelper = new TimeoutHelper();
yield return NetcodeIntegrationTest.WaitForConditionOrTimeOut(() => m_ClientDisconnected, timeoutHelper);
// We need to do this to remove other associated client properties/values from NetcodeIntegrationTestHelpers
NetcodeIntegrationTestHelpers.StopOneClient(clients[0]);
// ensure the object was destroyed
Assert.False(server.SpawnManager.SpawnedObjects.Any(x => x.Value.IsPlayerObject && x.Value.OwnerClientId == clients[0].LocalClientId));
// cleanup
NetcodeIntegrationTestHelpers.Destroy();
DestroyWithOwner,
DontDestroyWithOwner
}
public enum ClientDisconnectType
{
ServerDisconnectsClient,
ClientDisconnectsFromServer
}
protected override int NumberOfClients => 1;
private OwnerPersistence m_OwnerPersistence;
private bool m_ClientDisconnected;
private ulong m_TransportClientId;
private ulong m_ClientId;
public DisconnectTests(OwnerPersistence ownerPersistence)
{
m_OwnerPersistence = ownerPersistence;
}
protected override void OnCreatePlayerPrefab()
{
m_PlayerPrefab.GetComponent<NetworkObject>().DontDestroyWithOwner = m_OwnerPersistence == OwnerPersistence.DontDestroyWithOwner;
base.OnCreatePlayerPrefab();
}
protected override void OnServerAndClientsCreated()
{
// Adjusting client and server timeout periods to reduce test time
// Get the tick frequency in milliseconds and triple it for the heartbeat timeout
var heartBeatTimeout = (int)(300 * (1.0f / m_ServerNetworkManager.NetworkConfig.TickRate));
var unityTransport = m_ServerNetworkManager.NetworkConfig.NetworkTransport as Transports.UTP.UnityTransport;
if (unityTransport != null)
{
unityTransport.HeartbeatTimeoutMS = heartBeatTimeout;
}
unityTransport = m_ClientNetworkManagers[0].NetworkConfig.NetworkTransport as Transports.UTP.UnityTransport;
if (unityTransport != null)
{
unityTransport.HeartbeatTimeoutMS = heartBeatTimeout;
}
base.OnServerAndClientsCreated();
}
protected override IEnumerator OnSetup()
{
m_ClientDisconnected = false;
m_ClientId = 0;
m_TransportClientId = 0;
return base.OnSetup();
}
/// <summary>
/// Used to detect the client disconnected on the server side
/// </summary>
private void OnClientDisconnectCallback(ulong obj)
{
m_ClientDisconnected = true;
}
[UnityTest]
public IEnumerator ClientDisconnectPlayerObjectCleanup()
/// <summary>
/// Conditional check to assure the transport to client (and vice versa) mappings are cleaned up
/// </summary>
private bool TransportIdCleanedUp()
{
// create server and client instances
NetcodeIntegrationTestHelpers.Create(1, out NetworkManager server, out NetworkManager[] clients);
// create prefab
var gameObject = new GameObject("PlayerObject");
var networkObject = gameObject.AddComponent<NetworkObject>();
networkObject.DontDestroyWithOwner = true;
NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(networkObject);
server.NetworkConfig.PlayerPrefab = gameObject;
for (int i = 0; i < clients.Length; i++)
if (m_ServerNetworkManager.ConnectionManager.TransportIdToClientId(m_TransportClientId) == m_ClientId)
{
clients[i].NetworkConfig.PlayerPrefab = gameObject;
return false;
}
// start server and connect clients
NetcodeIntegrationTestHelpers.Start(false, server, clients);
if (m_ServerNetworkManager.ConnectionManager.ClientIdToTransportId(m_ClientId) == m_TransportClientId)
{
return false;
}
return true;
}
// wait for connection on client side
yield return NetcodeIntegrationTestHelpers.WaitForClientsConnected(clients);
/// <summary>
/// Conditional check to make sure the client player object no longer exists on the server side
/// </summary>
private bool DoesServerStillHaveSpawnedPlayerObject()
{
if (m_PlayerNetworkObjects[m_ServerNetworkManager.LocalClientId].ContainsKey(m_ClientId))
{
var playerObject = m_PlayerNetworkObjects[m_ServerNetworkManager.LocalClientId][m_ClientId];
if (playerObject != null && playerObject.IsSpawned)
{
return false;
}
}
return !m_ServerNetworkManager.SpawnManager.SpawnedObjects.Any(x => x.Value.IsPlayerObject && x.Value.OwnerClientId == m_ClientId);
}
// wait for connection on server side
yield return NetcodeIntegrationTestHelpers.WaitForClientConnectedToServer(server);
[UnityTest]
public IEnumerator ClientPlayerDisconnected([Values] ClientDisconnectType clientDisconnectType)
{
m_ClientId = m_ClientNetworkManagers[0].LocalClientId;
// disconnect the remote client
m_ClientDisconnected = false;
var serverSideClientPlayer = m_ServerNetworkManager.ConnectionManager.ConnectedClients[m_ClientId].PlayerObject;
server.OnClientDisconnectCallback += OnClientDisconnectCallback;
m_TransportClientId = m_ServerNetworkManager.ConnectionManager.ClientIdToTransportId(m_ClientId);
var serverSideClientPlayer = server.ConnectedClients[clients[0].LocalClientId].PlayerObject;
if (clientDisconnectType == ClientDisconnectType.ServerDisconnectsClient)
{
m_ClientNetworkManagers[0].OnClientDisconnectCallback += OnClientDisconnectCallback;
m_ServerNetworkManager.DisconnectClient(m_ClientId);
}
else
{
m_ServerNetworkManager.OnClientDisconnectCallback += OnClientDisconnectCallback;
// Stopping the client is the same as the client disconnecting
NetcodeIntegrationTestHelpers.StopOneClient(clients[0]);
yield return StopOneClient(m_ClientNetworkManagers[0]);
}
var timeoutHelper = new TimeoutHelper();
yield return NetcodeIntegrationTest.WaitForConditionOrTimeOut(() => m_ClientDisconnected, timeoutHelper);
yield return WaitForConditionOrTimeOut(() => m_ClientDisconnected);
AssertOnTimeout("Timed out waiting for client to disconnect!");
// ensure the object was destroyed
Assert.True(serverSideClientPlayer.IsOwnedByServer, $"The client's player object's ownership was not transferred back to the server!");
if (m_OwnerPersistence == OwnerPersistence.DestroyWithOwner)
{
// When we are destroying with the owner, validate the player object is destroyed on the server side
yield return WaitForConditionOrTimeOut(DoesServerStillHaveSpawnedPlayerObject);
AssertOnTimeout("Timed out waiting for client's player object to be destroyed!");
}
else
{
// When we are not destroying with the owner, ensure the player object's ownership was transferred back to the server
yield return WaitForConditionOrTimeOut(() => serverSideClientPlayer.IsOwnedByServer);
AssertOnTimeout("The client's player object's ownership was not transferred back to the server!");
}
// cleanup
NetcodeIntegrationTestHelpers.Destroy();
yield return WaitForConditionOrTimeOut(TransportIdCleanedUp);
AssertOnTimeout("Timed out waiting for transport and client id mappings to be cleaned up!");
}
}
}