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

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

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

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

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

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

### Fixed

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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