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

## [2.2.0] - 2024-12-12

### Added

- Added `NetworkObject.OwnershipStatus.SessionOwner` to allow Network Objects to be distributable and only owned by the Session Owner. This flag will override all other `OwnershipStatus` flags. (#3175)
- Added `UnityTransport.GetEndpoint` method to provide a way to obtain `NetworkEndpoint` information of a connection via client identifier. (#3130)
- Added `NetworkTransport.OnEarlyUpdate` and `NetworkTransport.OnPostLateUpdate` methods to provide more control over handling transport related events at the start and end of each frame. (#3113)

### Fixed

- Fixed issue where the server, host, or session owner would not populate the in-scene place `NetworkObject` table if the scene was loaded prior to starting the `NetworkManager`. (#3177)
- Fixed issue where the `NetworkObjectIdHash` value could be incorrect when entering play mode while still in prefab edit mode with pending changes and using MPPM. (#3162)
- Fixed issue where a sever only `NetworkManager` instance would spawn the actual `NetworkPrefab`'s `GameObject` as opposed to creating an instance of it. (#3160)
- Fixed issue where only the session owner (as opposed to all clients) would handle spawning prefab overrides properly when using a distributed authority network topology. (#3160)
- Fixed issue where an exception was thrown when calling `NetworkManager.Shutdown` after calling `UnityTransport.Shutdown`. (#3118)
- Fixed issue where `NetworkList` properties on in-scene placed `NetworkObject`s could cause small memory leaks when entering playmode. (#3147)
- Fixed in-scene `NertworkObject` synchronization issue when loading a scene with currently connected clients connected to a session created by a `NetworkManager` started as a server (i.e. not as a host). (#3133)
- Fixed issue where a `NetworkManager` started as a server would not add itself as an observer to in-scene placed `NetworkObject`s instantiated and spawned by a scene loading event. (#3133)
- Fixed issue where spawning a player using `NetworkObject.InstantiateAndSpawn` or `NetworkSpawnManager.InstantiateAndSpawn` would not update the `NetworkSpawnManager.PlayerObjects` or assign the newly spawned player to the `NetworkClient.PlayerObject`. (#3122)
- Fixed issue where queued UnitTransport (NetworkTransport) message batches were being sent on the next frame. They are now sent at the end of the frame during `PostLateUpdate`.  (#3113)
- Fixed issue where `NotOwnerRpcTarget` or `OwnerRpcTarget` were not using their replacements `NotAuthorityRpcTarget` and `AuthorityRpcTarget` which would invoke a warning. (#3111)
- Fixed issue where client is removed as an observer from spawned objects when their player instance is despawned. (#3110)
- Fixed issue where `NetworkAnimator` would statically allocate write buffer space for `Animator` parameters that could cause a write error if the number of parameters exceeded the space allocated. (#3108)

### Changed

- In-scene placed `NetworkObject`s have been made distributable when balancing object distribution after a connection event. (#3175)
- Optimised `NetworkVariable` and `NetworkTransform` related packets when in Distributed Authority mode.
- The Debug Simulator section of the Unity Transport component was removed. This section was not functional anymore and users are now recommended to use the more featureful [Network Simulator](https://docs-multiplayer.unity3d.com/tools/current/tools-network-simulator/) tool from the Multiplayer Tools package instead. (#3121)
This commit is contained in:
Unity Technologies
2024-12-12 00:00:00 +00:00
parent 016788c21e
commit 8fe07bbad2
78 changed files with 2243 additions and 1187 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
Runtime/Messaging/RpcTargets/ClientsAndHostRpcTarget.cs
View File

@@ -17,7 +17,8 @@ namespace Unity.Netcode
// ClientsAndHost sends to everyone who runs any client logic
// So if the server is a host, this target includes it (as hosts run client logic)
// If the server is not a host, this target leaves it out, ergo the selection of NotServer.
if (behaviour.NetworkManager.ServerIsHost)
// If we are in distributed authority mode and connected to a service, then send to all clients.
if (behaviour.NetworkManager.ServerIsHost || (m_NetworkManager.DistributedAuthorityMode && m_NetworkManager.CMBServiceConnection))
{
m_UnderlyingTarget = behaviour.RpcTarget.Everyone;
}

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

@@ -4,12 +4,14 @@ namespace Unity.Netcode
{
private IGroupRpcTarget m_GroupSendTarget;
private ServerRpcTarget m_ServerRpcTarget;
private NotAuthorityRpcTarget m_NotAuthorityRpcTarget;
private LocalSendRpcTarget m_LocalSendRpcTarget;
public override void Dispose()
{
m_ServerRpcTarget.Dispose();
m_LocalSendRpcTarget.Dispose();
m_NotAuthorityRpcTarget.Dispose();
if (m_GroupSendTarget != null)
{
m_GroupSendTarget.Target.Dispose();
@@ -19,6 +21,13 @@ namespace Unity.Netcode
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
// Not owner is the same as not authority in distributed authority mode
if (m_NetworkManager.DistributedAuthorityMode)
{
m_NotAuthorityRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
return;
}
if (m_GroupSendTarget == null)
{
if (behaviour.IsServer)
@@ -86,6 +95,7 @@ namespace Unity.Netcode
{
m_ServerRpcTarget = new ServerRpcTarget(manager);
m_LocalSendRpcTarget = new LocalSendRpcTarget(manager);
m_NotAuthorityRpcTarget = new NotAuthorityRpcTarget(manager);
}
}
}

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

@@ -51,7 +51,13 @@ namespace Unity.Netcode
continue;
}
if (clientId == behaviour.NetworkManager.LocalClientId)
// If we are in distributed authority mode and connected to the service, then we exclude the owner/authority from the list
if (m_NetworkManager.DistributedAuthorityMode && m_NetworkManager.CMBServiceConnection && clientId == behaviour.OwnerClientId)
{
continue;
}
if (clientId == m_NetworkManager.LocalClientId)
{
m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
continue;

11
Runtime/Messaging/RpcTargets/OwnerRpcTarget.cs
View File

@@ -5,9 +5,12 @@ namespace Unity.Netcode
private IIndividualRpcTarget m_UnderlyingTarget;
private LocalSendRpcTarget m_LocalRpcTarget;
private ServerRpcTarget m_ServerRpcTarget;
private AuthorityRpcTarget m_AuthorityRpcTarget;
public override void Dispose()
{
m_AuthorityRpcTarget.Dispose();
m_ServerRpcTarget.Dispose();
m_LocalRpcTarget.Dispose();
if (m_UnderlyingTarget != null)
{
@@ -18,6 +21,13 @@ namespace Unity.Netcode
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
// Sending to owner is the same as sending to authority in distributed authority mode
if (m_NetworkManager.DistributedAuthorityMode)
{
m_AuthorityRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
return;
}
if (behaviour.OwnerClientId == behaviour.NetworkManager.LocalClientId)
{
m_LocalRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
@@ -49,6 +59,7 @@ namespace Unity.Netcode
{
m_LocalRpcTarget = new LocalSendRpcTarget(manager);
m_ServerRpcTarget = new ServerRpcTarget(manager);
m_AuthorityRpcTarget = new AuthorityRpcTarget(manager);
}
}
}

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

@@ -79,9 +79,28 @@ namespace Unity.Netcode
SpecifiedInParams
}
/// <summary>
/// This parameter configures a performance optimization. This optimization is not valid in all situations.<br />
/// Because BaseRpcTarget is a managed type, allocating a new one is expensive, as it puts pressure on the garbage collector.
/// </summary>
/// <remarks>
/// When using a <see cref="Temp"/> allocation type for the RPC target(s):<br />
/// You typically don't need to worry about persisting the <see cref="BaseRpcTarget"/> generated.
/// When using a <see cref="Persistent"/> allocation type for the RPC target(s): <br />
/// You will want to use <see cref="RpcTarget"/>, which returns <see cref="BaseRpcTarget"/>, during <see cref="NetworkBehaviour"/> initialization (i.e. <see cref="NetworkBehaviour.OnNetworkPostSpawn"/>) and it to a property.<br />
/// Then, When invoking the RPC, you would use your <see cref="BaseRpcTarget"/> which is a persisted allocation of a given set of client identifiers.
/// !! Important !!<br />
/// You will want to invoke <see cref="BaseRpcTarget.Dispose"/> of any persisted properties created via <see cref="RpcTarget"/> when despawning or destroying the associated <see cref="NetworkBehaviour"/> component's <see cref="NetworkObject"/>. Not doing so will result in small memory leaks.
/// </remarks>
public enum RpcTargetUse
{
/// <summary>
/// Creates a temporary <see cref="BaseRpcTarget"/> used for the frame an <see cref="RpcAttribute"/> decorated method is invoked.
/// </summary>
Temp,
/// <summary>
/// Creates a persisted <see cref="BaseRpcTarget"/> that does not change and will persist until <see cref="BaseRpcTarget.Dispose"/> is called.
/// </summary>
Persistent
}

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

@@ -1,8 +1,10 @@
using Unity.Collections;
namespace Unity.Netcode
{
internal class ServerRpcTarget : BaseRpcTarget
{
protected BaseRpcTarget m_UnderlyingTarget;
protected ProxyRpcTarget m_ProxyRpcTarget;
public override void Dispose()
{
@@ -11,13 +13,62 @@ namespace Unity.Netcode
m_UnderlyingTarget.Dispose();
m_UnderlyingTarget = null;
}
if (m_ProxyRpcTarget != null)
{
m_ProxyRpcTarget.Dispose();
m_ProxyRpcTarget = null;
}
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
// For distributed authority the "server" is considered the authority of the object
if (behaviour.NetworkManager.DistributedAuthorityMode && behaviour.NetworkManager.CMBServiceConnection)
{
UnityEngine.Debug.LogWarning("[Invalid Target] There is no server to send to when in Distributed Authority mode!");
// If the local instance is the owner, then invoke the message locally on this behaviour
if (behaviour.IsOwner)
{
var context = new NetworkContext
{
SenderId = m_NetworkManager.LocalClientId,
Timestamp = m_NetworkManager.RealTimeProvider.RealTimeSinceStartup,
SystemOwner = m_NetworkManager,
// header information isn't valid since it's not a real message.
// RpcMessage doesn't access this stuff so it's just left empty.
Header = new NetworkMessageHeader(),
SerializedHeaderSize = 0,
MessageSize = 0
};
using var tempBuffer = new FastBufferReader(message.WriteBuffer, Allocator.None);
message.ReadBuffer = tempBuffer;
message.Handle(ref context);
// If enabled, then add the RPC metrics for this
#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
int length = tempBuffer.Length;
if (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName))
{
m_NetworkManager.NetworkMetrics.TrackRpcSent(
m_NetworkManager.LocalClientId,
behaviour.NetworkObject,
rpcMethodName,
behaviour.__getTypeName(),
length);
}
#endif
}
else // Otherwise, send a proxied message to the owner of the object
{
if (m_ProxyRpcTarget == null)
{
m_ProxyRpcTarget = new ProxyRpcTarget(behaviour.OwnerClientId, m_NetworkManager);
}
else
{
m_ProxyRpcTarget.SetClientId(behaviour.OwnerClientId);
}
m_ProxyRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
}
return;
}