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.8.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.8.0] - 2023-12-12

### Added

- Added a new RPC attribute, which is simply `Rpc`. (#2762)
  - This is a generic attribute that can perform the functions of both Server and Client RPCs, as well as enabling client-to-client RPCs. Includes several default targets: `Server`, `NotServer`, `Owner`, `NotOwner`, `Me`, `NotMe`, `ClientsAndHost`, and `Everyone`. Runtime overrides are available for any of these targets, as well as for sending to a specific ID or groups of IDs.
  - This attribute also includes the ability to defer RPCs that are sent to the local process to the start of the next frame instead of executing them immediately, treating them as if they had gone across the network. The default behavior is to execute immediately.
  - This attribute effectively replaces `ServerRpc` and `ClientRpc`. `ServerRpc` and `ClientRpc` remain in their existing forms for backward compatibility, but `Rpc` will be the recommended and most supported option.
- Added `NetworkManager.OnConnectionEvent` as a unified connection event callback to notify clients and servers of all client connections and disconnections within the session (#2762)
- Added `NetworkManager.ServerIsHost` and `NetworkBehaviour.ServerIsHost` to allow a client to tell if it is connected to a host or to a dedicated server (#2762)
- Added `SceneEventProgress.SceneManagementNotEnabled` return status to be returned when a `NetworkSceneManager` method is invoked and scene management is not enabled. (#2735)
- Added `SceneEventProgress.ServerOnlyAction` return status to be returned when a `NetworkSceneManager` method is invoked by a client. (#2735)
- Added `NetworkObject.InstantiateAndSpawn` and `NetworkSpawnManager.InstantiateAndSpawn` methods to simplify prefab spawning by assuring that the prefab is valid and applies any override prior to instantiating the `GameObject` and spawning the `NetworkObject` instance. (#2710)

### Fixed

- Fixed issue where a client disconnected by a server-host would not receive a local notification. (#2789)
- Fixed issue where a server-host could shutdown during a relay connection but periodically the transport disconnect message sent to any connected clients could be dropped. (#2789)
- Fixed issue where a host could disconnect its local client but remain running as a server. (#2789)
- Fixed issue where `OnClientDisconnectedCallback` was not being invoked under certain conditions. (#2789)
- Fixed issue where `OnClientDisconnectedCallback` was always returning 0 as the client identifier. (#2789)
- Fixed issue where if a host or server shutdown while a client owned NetworkObjects (other than the player) it would throw an exception. (#2789)
- Fixed issue where setting values on a `NetworkVariable` or `NetworkList` within `OnNetworkDespawn` during a shutdown sequence would throw an exception. (#2789)
- Fixed issue where a teleport state could potentially be overridden by a previous unreliable delta state. (#2777)
- Fixed issue where `NetworkTransform` was using the `NetworkManager.ServerTime.Tick` as opposed to `NetworkManager.NetworkTickSystem.ServerTime.Tick` during the authoritative side's tick update where it performed a delta state check. (#2777)
- Fixed issue where a parented in-scene placed NetworkObject would be destroyed upon a client or server exiting a network session but not unloading the original scene in which the NetworkObject was placed. (#2737)
- Fixed issue where during client synchronization and scene loading, when client synchronization or the scene loading mode are set to `LoadSceneMode.Single`, a `CreateObjectMessage` could be received, processed, and the resultant spawned `NetworkObject` could be instantiated in the client's currently active scene that could, towards the end of the client synchronization or loading process, be unloaded and cause the newly created `NetworkObject` to be destroyed (and throw and exception). (#2735)
- Fixed issue where a `NetworkTransform` instance with interpolation enabled would result in wide visual motion gaps (stuttering) under above normal latency conditions and a 1-5% or higher packet are drop rate. (#2713)
- Fixed issue where  you could not have multiple source network prefab overrides targeting the same network prefab as their override. (#2710)

### Changed
- Changed the server or host shutdown so it will now perform a "soft shutdown" when `NetworkManager.Shutdown` is invoked. This will send a disconnect notification to all connected clients and the server-host will wait for all connected clients to disconnect or timeout after a 5 second period before completing the shutdown process. (#2789)
- Changed `OnClientDisconnectedCallback` will now return the assigned client identifier on the local client side if the client was approved and assigned one prior to being disconnected. (#2789)
- Changed `NetworkTransform.SetState` (and related methods) now are cumulative during a fractional tick period and sent on the next pending tick. (#2777)
- `NetworkManager.ConnectedClientsIds` is now accessible on the client side and will contain the list of all clients in the session, including the host client if the server is operating in host mode (#2762)
- Changed `NetworkSceneManager` to return a `SceneEventProgress` status and not throw exceptions for methods invoked when scene management is disabled and when a client attempts to access a `NetworkSceneManager` method by a client. (#2735)
- Changed `NetworkTransform` authoritative instance tick registration so a single `NetworkTransform` specific tick event update will update all authoritative instances to improve perofmance. (#2713)
- Changed `NetworkPrefabs.OverrideToNetworkPrefab` dictionary is no longer used/populated due to it ending up being related to a regression bug and not allowing more than one override to be assigned to a network prefab asset. (#2710)
- Changed in-scene placed `NetworkObject`s now store their source network prefab asset's `GlobalObjectIdHash` internally that is used, when scene management is disabled, by clients to spawn the correct prefab even if the `NetworkPrefab` entry has an override. This does not impact dynamically spawning the same prefab which will yield the override on both host and client. (#2710)
- Changed in-scene placed `NetworkObject`s no longer require a `NetworkPrefab` entry with `GlobalObjectIdHash` override in order for clients to properly synchronize. (#2710)
- Changed in-scene placed `NetworkObject`s now set their `IsSceneObject` value when generating their `GlobalObjectIdHash` value. (#2710)
- Changed the default `NetworkConfig.SpawnTimeout` value from 1.0s to 10.0s. (#2710)
This commit is contained in:
Unity Technologies
2023-12-12 00:00:00 +00:00
parent 514166e159
commit 07f206ff9e
99 changed files with 8667 additions and 1710 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
Runtime/Messaging/RpcTargets/BaseRpcTarget.cs Normal file
View File

@@ -0,0 +1,57 @@
using System;
namespace Unity.Netcode
{
public abstract class BaseRpcTarget : IDisposable
{
protected NetworkManager m_NetworkManager;
private bool m_Locked;
internal void Lock()
{
m_Locked = true;
}
internal void Unlock()
{
m_Locked = false;
}
internal BaseRpcTarget(NetworkManager manager)
{
m_NetworkManager = manager;
}
protected void CheckLockBeforeDispose()
{
if (m_Locked)
{
throw new Exception($"RPC targets obtained through {nameof(RpcTargetUse)}.{RpcTargetUse.Temp} may not be disposed.");
}
}
public abstract void Dispose();
internal abstract void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams);
private protected void SendMessageToClient(NetworkBehaviour behaviour, ulong clientId, ref RpcMessage message, NetworkDelivery delivery)
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
var size =
#endif
behaviour.NetworkManager.MessageManager.SendMessage(ref message, delivery, clientId);
#if DEVELOPMENT_BUILD || UNITY_EDITOR
if (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName))
{
behaviour.NetworkManager.NetworkMetrics.TrackRpcSent(
clientId,
behaviour.NetworkObject,
rpcMethodName,
behaviour.__getTypeName(),
size);
}
#endif
}
}
}

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

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

37
Runtime/Messaging/RpcTargets/ClientsAndHostRpcTarget.cs Normal file
View File

@@ -0,0 +1,37 @@
namespace Unity.Netcode
{
internal class ClientsAndHostRpcTarget : BaseRpcTarget
{
private BaseRpcTarget m_UnderlyingTarget;
public override void Dispose()
{
m_UnderlyingTarget = null;
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
if (m_UnderlyingTarget == null)
{
// NotServer treats a host as being a server and will not send to it
// 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)
{
m_UnderlyingTarget = behaviour.RpcTarget.Everyone;
}
else
{
m_UnderlyingTarget = behaviour.RpcTarget.NotServer;
}
}
m_UnderlyingTarget.Send(behaviour, ref message, delivery, rpcParams);
}
internal ClientsAndHostRpcTarget(NetworkManager manager) : base(manager)
{
}
}
}

3
Runtime/Messaging/RpcTargets/ClientsAndHostRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: c9f883d678ec4715b160dd9497d5f42d
timeCreated: 1699481382

34
Runtime/Messaging/RpcTargets/DirectSendRpcTarget.cs Normal file
View File

@@ -0,0 +1,34 @@
namespace Unity.Netcode
{
internal class DirectSendRpcTarget : BaseRpcTarget, IIndividualRpcTarget
{
public BaseRpcTarget Target => this;
internal ulong ClientId;
public override void Dispose()
{
CheckLockBeforeDispose();
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
SendMessageToClient(behaviour, ClientId, ref message, delivery);
}
public void SetClientId(ulong clientId)
{
ClientId = clientId;
}
internal DirectSendRpcTarget(NetworkManager manager) : base(manager)
{
}
internal DirectSendRpcTarget(ulong clientId, NetworkManager manager) : base(manager)
{
ClientId = clientId;
}
}
}

3
Runtime/Messaging/RpcTargets/DirectSendRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 077544cfd0b94cfc8a2a55d3828b74bb
timeCreated: 1697824873

26
Runtime/Messaging/RpcTargets/EveryoneRpcTarget.cs Normal file
View File

@@ -0,0 +1,26 @@
namespace Unity.Netcode
{
internal class EveryoneRpcTarget : BaseRpcTarget
{
private NotServerRpcTarget m_NotServerRpcTarget;
private ServerRpcTarget m_ServerRpcTarget;
public override void Dispose()
{
m_NotServerRpcTarget.Dispose();
m_ServerRpcTarget.Dispose();
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
m_NotServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
}
internal EveryoneRpcTarget(NetworkManager manager) : base(manager)
{
m_NotServerRpcTarget = new NotServerRpcTarget(manager);
m_ServerRpcTarget = new ServerRpcTarget(manager);
}
}
}

3
Runtime/Messaging/RpcTargets/EveryoneRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 675d4a5c79fc47078092ac15d255745d
timeCreated: 1697824941

9
Runtime/Messaging/RpcTargets/IGroupRpcTarget.cs Normal file
View File

@@ -0,0 +1,9 @@
namespace Unity.Netcode
{
internal interface IGroupRpcTarget
{
void Add(ulong clientId);
void Clear();
BaseRpcTarget Target { get; }
}
}

3
Runtime/Messaging/RpcTargets/IGroupRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: beb19a6bb1334252a89b21c8490f7cbe
timeCreated: 1697825109

8
Runtime/Messaging/RpcTargets/IIndividualRpcTarget.cs Normal file
View File

@@ -0,0 +1,8 @@
namespace Unity.Netcode
{
internal interface IIndividualRpcTarget
{
void SetClientId(ulong clientId);
BaseRpcTarget Target { get; }
}
}

3
Runtime/Messaging/RpcTargets/IIndividualRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: c658d9641f564d9890bef4f558f1cea6
timeCreated: 1697825115

67
Runtime/Messaging/RpcTargets/LocalSendRpcTarget.cs Normal file
View File

@@ -0,0 +1,67 @@
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
namespace Unity.Netcode
{
internal class LocalSendRpcTarget : BaseRpcTarget
{
public override void Dispose()
{
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
var networkManager = behaviour.NetworkManager;
var context = new NetworkContext
{
SenderId = m_NetworkManager.LocalClientId,
Timestamp = networkManager.RealTimeProvider.RealTimeSinceStartup,
SystemOwner = 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
};
int length;
if (rpcParams.Send.LocalDeferMode == LocalDeferMode.Defer)
{
using var serializedWriter = new FastBufferWriter(message.WriteBuffer.Length + UnsafeUtility.SizeOf<RpcMetadata>(), Allocator.Temp, int.MaxValue);
message.Serialize(serializedWriter, message.Version);
using var reader = new FastBufferReader(serializedWriter, Allocator.None);
context.Header = new NetworkMessageHeader
{
MessageSize = (uint)reader.Length,
MessageType = m_NetworkManager.MessageManager.GetMessageType(typeof(RpcMessage))
};
behaviour.NetworkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnNextFrame, 0, reader, ref context);
length = reader.Length;
}
else
{
using var tempBuffer = new FastBufferReader(message.WriteBuffer, Allocator.None);
message.ReadBuffer = tempBuffer;
message.Handle(ref context);
length = tempBuffer.Length;
}
#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,
behaviour.NetworkObject,
rpcMethodName,
behaviour.__getTypeName(),
length);
}
#endif
}
internal LocalSendRpcTarget(NetworkManager manager) : base(manager)
{
}
}
}

3
Runtime/Messaging/RpcTargets/LocalSendRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: c3b290cdc20d4d2293652ec79652962a
timeCreated: 1697824985

67
Runtime/Messaging/RpcTargets/NotMeRpcTarget.cs Normal file
View File

@@ -0,0 +1,67 @@
namespace Unity.Netcode
{
internal class NotMeRpcTarget : BaseRpcTarget
{
private IGroupRpcTarget m_GroupSendTarget;
private ServerRpcTarget m_ServerRpcTarget;
public override void Dispose()
{
m_ServerRpcTarget.Dispose();
if (m_GroupSendTarget != null)
{
m_GroupSendTarget.Target.Dispose();
m_GroupSendTarget = null;
}
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
if (m_GroupSendTarget == null)
{
if (behaviour.IsServer)
{
m_GroupSendTarget = new RpcTargetGroup(m_NetworkManager);
}
else
{
m_GroupSendTarget = new ProxyRpcTargetGroup(m_NetworkManager);
}
}
m_GroupSendTarget.Clear();
if (behaviour.IsServer)
{
foreach (var clientId in behaviour.NetworkObject.Observers)
{
if (clientId == behaviour.NetworkManager.LocalClientId)
{
continue;
}
m_GroupSendTarget.Add(clientId);
}
}
else
{
foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
{
if (clientId == behaviour.NetworkManager.LocalClientId)
{
continue;
}
m_GroupSendTarget.Add(clientId);
}
}
m_GroupSendTarget.Target.Send(behaviour, ref message, delivery, rpcParams);
if (!behaviour.IsServer)
{
m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
}
}
internal NotMeRpcTarget(NetworkManager manager) : base(manager)
{
m_ServerRpcTarget = new ServerRpcTarget(manager);
}
}
}

3
Runtime/Messaging/RpcTargets/NotMeRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 99cd5e8be7bd454bab700ee08b8dad7b
timeCreated: 1697824966

83
Runtime/Messaging/RpcTargets/NotOwnerRpcTarget.cs Normal file
View File

@@ -0,0 +1,83 @@
namespace Unity.Netcode
{
internal class NotOwnerRpcTarget : BaseRpcTarget
{
private IGroupRpcTarget m_GroupSendTarget;
private ServerRpcTarget m_ServerRpcTarget;
private LocalSendRpcTarget m_LocalSendRpcTarget;
public override void Dispose()
{
m_ServerRpcTarget.Dispose();
m_LocalSendRpcTarget.Dispose();
if (m_GroupSendTarget != null)
{
m_GroupSendTarget.Target.Dispose();
m_GroupSendTarget = null;
}
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
if (m_GroupSendTarget == null)
{
if (behaviour.IsServer)
{
m_GroupSendTarget = new RpcTargetGroup(m_NetworkManager);
}
else
{
m_GroupSendTarget = new ProxyRpcTargetGroup(m_NetworkManager);
}
}
m_GroupSendTarget.Clear();
if (behaviour.IsServer)
{
foreach (var clientId in behaviour.NetworkObject.Observers)
{
if (clientId == behaviour.OwnerClientId)
{
continue;
}
if (clientId == behaviour.NetworkManager.LocalClientId)
{
m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
continue;
}
m_GroupSendTarget.Add(clientId);
}
}
else
{
foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
{
if (clientId == behaviour.OwnerClientId)
{
continue;
}
if (clientId == behaviour.NetworkManager.LocalClientId)
{
m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
continue;
}
m_GroupSendTarget.Add(clientId);
}
}
m_GroupSendTarget.Target.Send(behaviour, ref message, delivery, rpcParams);
if (behaviour.OwnerClientId != NetworkManager.ServerClientId)
{
m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
}
}
internal NotOwnerRpcTarget(NetworkManager manager) : base(manager)
{
m_ServerRpcTarget = new ServerRpcTarget(manager);
m_LocalSendRpcTarget = new LocalSendRpcTarget(manager);
}
}
}

3
Runtime/Messaging/RpcTargets/NotOwnerRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: d7bc66c5253b44d09ad978ea9e51c96f
timeCreated: 1698789420

72
Runtime/Messaging/RpcTargets/NotServerRpcTarget.cs Normal file
View File

@@ -0,0 +1,72 @@
namespace Unity.Netcode
{
internal class NotServerRpcTarget : BaseRpcTarget
{
private IGroupRpcTarget m_GroupSendTarget;
private LocalSendRpcTarget m_LocalSendRpcTarget;
public override void Dispose()
{
m_LocalSendRpcTarget.Dispose();
if (m_GroupSendTarget != null)
{
m_GroupSendTarget.Target.Dispose();
m_GroupSendTarget = null;
}
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
if (m_GroupSendTarget == null)
{
if (behaviour.IsServer)
{
m_GroupSendTarget = new RpcTargetGroup(m_NetworkManager);
}
else
{
m_GroupSendTarget = new ProxyRpcTargetGroup(m_NetworkManager);
}
}
m_GroupSendTarget.Clear();
if (behaviour.IsServer)
{
foreach (var clientId in behaviour.NetworkObject.Observers)
{
if (clientId == NetworkManager.ServerClientId)
{
continue;
}
m_GroupSendTarget.Add(clientId);
}
}
else
{
foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
{
if (clientId == NetworkManager.ServerClientId)
{
continue;
}
if (clientId == behaviour.NetworkManager.LocalClientId)
{
m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
continue;
}
m_GroupSendTarget.Add(clientId);
}
}
m_GroupSendTarget.Target.Send(behaviour, ref message, delivery, rpcParams);
}
internal NotServerRpcTarget(NetworkManager manager) : base(manager)
{
m_LocalSendRpcTarget = new LocalSendRpcTarget(manager);
}
}
}

3
Runtime/Messaging/RpcTargets/NotServerRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: c63787afe52f45ffbd5d801f78e7c0d6
timeCreated: 1697824954

54
Runtime/Messaging/RpcTargets/OwnerRpcTarget.cs Normal file
View File

@@ -0,0 +1,54 @@
namespace Unity.Netcode
{
internal class OwnerRpcTarget : BaseRpcTarget
{
private IIndividualRpcTarget m_UnderlyingTarget;
private LocalSendRpcTarget m_LocalRpcTarget;
private ServerRpcTarget m_ServerRpcTarget;
public override void Dispose()
{
m_LocalRpcTarget.Dispose();
if (m_UnderlyingTarget != null)
{
m_UnderlyingTarget.Target.Dispose();
m_UnderlyingTarget = null;
}
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
if (behaviour.OwnerClientId == behaviour.NetworkManager.LocalClientId)
{
m_LocalRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
return;
}
if (behaviour.OwnerClientId == NetworkManager.ServerClientId)
{
m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
return;
}
if (m_UnderlyingTarget == null)
{
if (behaviour.NetworkManager.IsServer)
{
m_UnderlyingTarget = new DirectSendRpcTarget(m_NetworkManager);
}
else
{
m_UnderlyingTarget = new ProxyRpcTarget(behaviour.OwnerClientId, m_NetworkManager);
}
}
m_UnderlyingTarget.SetClientId(behaviour.OwnerClientId);
m_UnderlyingTarget.Target.Send(behaviour, ref message, delivery, rpcParams);
}
internal OwnerRpcTarget(NetworkManager manager) : base(manager)
{
m_LocalRpcTarget = new LocalSendRpcTarget(manager);
m_ServerRpcTarget = new ServerRpcTarget(manager);
}
}
}

3
Runtime/Messaging/RpcTargets/OwnerRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 23c4d52455fc419aaf03094617894257
timeCreated: 1697824972

16
Runtime/Messaging/RpcTargets/ProxyRpcTarget.cs Normal file
View File

@@ -0,0 +1,16 @@
namespace Unity.Netcode
{
internal class ProxyRpcTarget : ProxyRpcTargetGroup, IIndividualRpcTarget
{
internal ProxyRpcTarget(ulong clientId, NetworkManager manager) : base(manager)
{
Add(clientId);
}
public void SetClientId(ulong clientId)
{
Clear();
Add(clientId);
}
}
}

3
Runtime/Messaging/RpcTargets/ProxyRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 86002805bb9e422e8b71581d1325357f
timeCreated: 1697825007

100
Runtime/Messaging/RpcTargets/ProxyRpcTargetGroup.cs Normal file
View File

@@ -0,0 +1,100 @@
using System;
using System.Collections.Generic;
using Unity.Collections;
namespace Unity.Netcode
{
internal class ProxyRpcTargetGroup : BaseRpcTarget, IDisposable, IGroupRpcTarget
{
public BaseRpcTarget Target => this;
private ServerRpcTarget m_ServerRpcTarget;
private LocalSendRpcTarget m_LocalSendRpcTarget;
private bool m_Disposed;
public NativeList<ulong> TargetClientIds;
internal HashSet<ulong> Ids = new HashSet<ulong>();
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
var proxyMessage = new ProxyMessage { Delivery = delivery, TargetClientIds = TargetClientIds.AsArray(), WrappedMessage = message };
#if DEVELOPMENT_BUILD || UNITY_EDITOR
var size =
#endif
behaviour.NetworkManager.MessageManager.SendMessage(ref proxyMessage, delivery, NetworkManager.ServerClientId);
#if DEVELOPMENT_BUILD || UNITY_EDITOR
if (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName))
{
foreach (var clientId in TargetClientIds)
{
behaviour.NetworkManager.NetworkMetrics.TrackRpcSent(
clientId,
behaviour.NetworkObject,
rpcMethodName,
behaviour.__getTypeName(),
size);
}
}
#endif
if (Ids.Contains(NetworkManager.ServerClientId))
{
m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
}
if (Ids.Contains(m_NetworkManager.LocalClientId))
{
m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
}
}
internal ProxyRpcTargetGroup(NetworkManager manager) : base(manager)
{
TargetClientIds = new NativeList<ulong>(Allocator.Persistent);
m_ServerRpcTarget = new ServerRpcTarget(manager);
m_LocalSendRpcTarget = new LocalSendRpcTarget(manager);
}
public override void Dispose()
{
CheckLockBeforeDispose();
if (!m_Disposed)
{
TargetClientIds.Dispose();
m_Disposed = true;
m_ServerRpcTarget.Dispose();
m_LocalSendRpcTarget.Dispose();
}
}
public void Add(ulong clientId)
{
if (!Ids.Contains(clientId))
{
Ids.Add(clientId);
if (clientId != NetworkManager.ServerClientId && clientId != m_NetworkManager.LocalClientId)
{
TargetClientIds.Add(clientId);
}
}
}
public void Remove(ulong clientId)
{
Ids.Remove(clientId);
for (var i = 0; i < TargetClientIds.Length; ++i)
{
if (TargetClientIds[i] == clientId)
{
TargetClientIds.RemoveAt(i);
break;
}
}
}
public void Clear()
{
Ids.Clear();
TargetClientIds.Clear();
}
}
}

3
Runtime/Messaging/RpcTargets/ProxyRpcTargetGroup.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 5728dbab532e46a88127510b4ec75af9
timeCreated: 1697825000

564
Runtime/Messaging/RpcTargets/RpcTarget.cs Normal file
View File

@@ -0,0 +1,564 @@
using System.Collections.Generic;
using Unity.Collections;
namespace Unity.Netcode
{
/// <summary>
/// Configuration for the default method by which an RPC is communicated across the network
/// </summary>
public enum SendTo
{
/// <summary>
/// Send to the NetworkObject's current owner.
/// Will execute locally if the local process is the owner.
/// </summary>
Owner,
/// <summary>
/// Send to everyone but the current owner, filtered to the current observer list.
/// Will execute locally if the local process is not the owner.
/// </summary>
NotOwner,
/// <summary>
/// Send to the server, regardless of ownership.
/// Will execute locally if invoked on the server.
/// </summary>
Server,
/// <summary>
/// Send to everyone but the server, filtered to the current observer list.
/// Will NOT send to a server running in host mode - it is still treated as a server.
/// If you want to send to servers when they are host, but not when they are dedicated server, use
/// <see cref="ClientsAndHost"/>.
/// <br />
/// <br />
/// Will execute locally if invoked on a client.
/// Will NOT execute locally if invoked on a server running in host mode.
/// </summary>
NotServer,
/// <summary>
/// Execute this RPC locally.
/// <br />
/// <br />
/// Normally this is no different from a standard function call.
/// <br />
/// <br />
/// Using the DeferLocal parameter of the attribute or the LocalDeferMode override in RpcSendParams,
/// this can allow an RPC to be processed on localhost with a one-frame delay as if it were sent over
/// the network.
/// </summary>
Me,
/// <summary>
/// Send this RPC to everyone but the local machine, filtered to the current observer list.
/// </summary>
NotMe,
/// <summary>
/// Send this RPC to everone, filtered to the current observer list.
/// Will execute locally.
/// </summary>
Everyone,
/// <summary>
/// Send this RPC to all clients, including the host, if a host exists.
/// If the server is running in host mode, this is the same as <see cref="Everyone" />.
/// If the server is running in dedicated server mode, this is the same as <see cref="NotServer" />.
/// </summary>
ClientsAndHost,
/// <summary>
/// This RPC cannot be sent without passing in a target in RpcSendParams.
/// </summary>
SpecifiedInParams
}
public enum RpcTargetUse
{
Temp,
Persistent
}
/// <summary>
/// Implementations of the various <see cref="SendTo"/> options, as well as additional runtime-only options
/// <see cref="Single"/>,
/// <see cref="Group(NativeArray{ulong})"/>,
/// <see cref="Group(NativeList{ulong})"/>,
/// <see cref="Group(ulong[])"/>,
/// <see cref="Group{T}(T)"/>, <see cref="Not(ulong)"/>,
/// <see cref="Not(NativeArray{ulong})"/>,
/// <see cref="Not(NativeList{ulong})"/>,
/// <see cref="Not(ulong[])"/>, and
/// <see cref="Not{T}(T)"/>
/// </summary>
public class RpcTarget
{
private NetworkManager m_NetworkManager;
internal RpcTarget(NetworkManager manager)
{
m_NetworkManager = manager;
Everyone = new EveryoneRpcTarget(manager);
Owner = new OwnerRpcTarget(manager);
NotOwner = new NotOwnerRpcTarget(manager);
Server = new ServerRpcTarget(manager);
NotServer = new NotServerRpcTarget(manager);
NotMe = new NotMeRpcTarget(manager);
Me = new LocalSendRpcTarget(manager);
ClientsAndHost = new ClientsAndHostRpcTarget(manager);
m_CachedProxyRpcTargetGroup = new ProxyRpcTargetGroup(manager);
m_CachedTargetGroup = new RpcTargetGroup(manager);
m_CachedDirectSendTarget = new DirectSendRpcTarget(manager);
m_CachedProxyRpcTarget = new ProxyRpcTarget(0, manager);
m_CachedProxyRpcTargetGroup.Lock();
m_CachedTargetGroup.Lock();
m_CachedDirectSendTarget.Lock();
m_CachedProxyRpcTarget.Lock();
}
public void Dispose()
{
Everyone.Dispose();
Owner.Dispose();
NotOwner.Dispose();
Server.Dispose();
NotServer.Dispose();
NotMe.Dispose();
Me.Dispose();
ClientsAndHost.Dispose();
m_CachedProxyRpcTargetGroup.Unlock();
m_CachedTargetGroup.Unlock();
m_CachedDirectSendTarget.Unlock();
m_CachedProxyRpcTarget.Unlock();
m_CachedProxyRpcTargetGroup.Dispose();
m_CachedTargetGroup.Dispose();
m_CachedDirectSendTarget.Dispose();
m_CachedProxyRpcTarget.Dispose();
}
/// <summary>
/// Send to the NetworkObject's current owner.
/// Will execute locally if the local process is the owner.
/// </summary>
public BaseRpcTarget Owner;
/// <summary>
/// Send to everyone but the current owner, filtered to the current observer list.
/// Will execute locally if the local process is not the owner.
/// </summary>
public BaseRpcTarget NotOwner;
/// <summary>
/// Send to the server, regardless of ownership.
/// Will execute locally if invoked on the server.
/// </summary>
public BaseRpcTarget Server;
/// <summary>
/// Send to everyone but the server, filtered to the current observer list.
/// Will NOT send to a server running in host mode - it is still treated as a server.
/// If you want to send to servers when they are host, but not when they are dedicated server, use
/// <see cref="SendTo.ClientsAndHost"/>.
/// <br />
/// <br />
/// Will execute locally if invoked on a client.
/// Will NOT execute locally if invoked on a server running in host mode.
/// </summary>
public BaseRpcTarget NotServer;
/// <summary>
/// Execute this RPC locally.
/// <br />
/// <br />
/// Normally this is no different from a standard function call.
/// <br />
/// <br />
/// Using the DeferLocal parameter of the attribute or the LocalDeferMode override in RpcSendParams,
/// this can allow an RPC to be processed on localhost with a one-frame delay as if it were sent over
/// the network.
/// </summary>
public BaseRpcTarget Me;
/// <summary>
/// Send this RPC to everyone but the local machine, filtered to the current observer list.
/// </summary>
public BaseRpcTarget NotMe;
/// <summary>
/// Send this RPC to everone, filtered to the current observer list.
/// Will execute locally.
/// </summary>
public BaseRpcTarget Everyone;
/// <summary>
/// Send this RPC to all clients, including the host, if a host exists.
/// If the server is running in host mode, this is the same as <see cref="Everyone" />.
/// If the server is running in dedicated server mode, this is the same as <see cref="NotServer" />.
/// </summary>
public BaseRpcTarget ClientsAndHost;
/// <summary>
/// Send to a specific single client ID.
/// </summary>
/// <param name="clientId"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Single(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Single(ulong clientId, RpcTargetUse use)
{
if (clientId == m_NetworkManager.LocalClientId)
{
return Me;
}
if (m_NetworkManager.IsServer || clientId == NetworkManager.ServerClientId)
{
if (use == RpcTargetUse.Persistent)
{
return new DirectSendRpcTarget(clientId, m_NetworkManager);
}
m_CachedDirectSendTarget.SetClientId(clientId);
return m_CachedDirectSendTarget;
}
if (use == RpcTargetUse.Persistent)
{
return new ProxyRpcTarget(clientId, m_NetworkManager);
}
m_CachedProxyRpcTarget.SetClientId(clientId);
return m_CachedProxyRpcTarget;
}
/// <summary>
/// Send to everyone EXCEPT a specific single client ID.
/// </summary>
/// <param name="excludedClientId"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Not(ulong excludedClientId, RpcTargetUse use)
{
IGroupRpcTarget target;
if (m_NetworkManager.IsServer)
{
if (use == RpcTargetUse.Persistent)
{
target = new RpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedTargetGroup;
}
}
else
{
if (use == RpcTargetUse.Persistent)
{
target = new ProxyRpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedProxyRpcTargetGroup;
}
}
target.Clear();
foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
{
if (clientId != excludedClientId)
{
target.Add(clientId);
}
}
// If ServerIsHost, ConnectedClientIds already contains ServerClientId and this would duplicate it.
if (!m_NetworkManager.ServerIsHost && excludedClientId != NetworkManager.ServerClientId)
{
target.Add(NetworkManager.ServerClientId);
}
return target.Target;
}
/// <summary>
/// Sends to a group of client IDs.
/// NativeArrays can be trivially constructed using Allocator.Temp, making this an efficient
/// Group method if the group list is dynamically constructed.
/// </summary>
/// <param name="clientIds"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Group(NativeArray<ulong> clientIds, RpcTargetUse use)
{
IGroupRpcTarget target;
if (m_NetworkManager.IsServer)
{
if (use == RpcTargetUse.Persistent)
{
target = new RpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedTargetGroup;
}
}
else
{
if (use == RpcTargetUse.Persistent)
{
target = new ProxyRpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedProxyRpcTargetGroup;
}
}
target.Clear();
foreach (var clientId in clientIds)
{
target.Add(clientId);
}
return target.Target;
}
/// <summary>
/// Sends to a group of client IDs.
/// NativeList can be trivially constructed using Allocator.Temp, making this an efficient
/// Group method if the group list is dynamically constructed.
/// </summary>
/// <param name="clientIds"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Group(NativeList<ulong> clientIds, RpcTargetUse use)
{
var asArray = clientIds.AsArray();
return Group(asArray, use);
}
/// <summary>
/// Sends to a group of client IDs.
/// Constructing arrays requires garbage collected allocations. This override is only recommended
/// if you either have no strict performance requirements, or have the group of client IDs cached so
/// it is not created each time.
/// </summary>
/// <param name="clientIds"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Group(ulong[] clientIds, RpcTargetUse use)
{
return Group(new NativeArray<ulong>(clientIds, Allocator.Temp), use);
}
/// <summary>
/// Sends to a group of client IDs.
/// This accepts any IEnumerable type, such as List&lt;ulong&gt;, but cannot be called without
/// a garbage collected allocation (even if the type itself is a struct type, due to boxing).
/// This override is only recommended if you either have no strict performance requirements,
/// or have the group of client IDs cached so it is not created each time.
/// </summary>
/// <param name="clientIds"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Group<T>(T clientIds, RpcTargetUse use) where T : IEnumerable<ulong>
{
IGroupRpcTarget target;
if (m_NetworkManager.IsServer)
{
if (use == RpcTargetUse.Persistent)
{
target = new RpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedTargetGroup;
}
}
else
{
if (use == RpcTargetUse.Persistent)
{
target = new ProxyRpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedProxyRpcTargetGroup;
}
}
target.Clear();
foreach (var clientId in clientIds)
{
target.Add(clientId);
}
return target.Target;
}
/// <summary>
/// Sends to everyone EXCEPT a group of client IDs.
/// NativeArrays can be trivially constructed using Allocator.Temp, making this an efficient
/// Group method if the group list is dynamically constructed.
/// </summary>
/// <param name="excludedClientIds"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Not(NativeArray<ulong> excludedClientIds, RpcTargetUse use)
{
IGroupRpcTarget target;
if (m_NetworkManager.IsServer)
{
if (use == RpcTargetUse.Persistent)
{
target = new RpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedTargetGroup;
}
}
else
{
if (use == RpcTargetUse.Persistent)
{
target = new ProxyRpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedProxyRpcTargetGroup;
}
}
target.Clear();
using var asASet = new NativeHashSet<ulong>(excludedClientIds.Length, Allocator.Temp);
foreach (var clientId in excludedClientIds)
{
asASet.Add(clientId);
}
foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
{
if (!asASet.Contains(clientId))
{
target.Add(clientId);
}
}
// If ServerIsHost, ConnectedClientIds already contains ServerClientId and this would duplicate it.
if (!m_NetworkManager.ServerIsHost && !asASet.Contains(NetworkManager.ServerClientId))
{
target.Add(NetworkManager.ServerClientId);
}
return target.Target;
}
/// <summary>
/// Sends to everyone EXCEPT a group of client IDs.
/// NativeList can be trivially constructed using Allocator.Temp, making this an efficient
/// Group method if the group list is dynamically constructed.
/// </summary>
/// <param name="excludedClientIds"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Not(NativeList<ulong> excludedClientIds, RpcTargetUse use)
{
var asArray = excludedClientIds.AsArray();
return Not(asArray, use);
}
/// <summary>
/// Sends to everyone EXCEPT a group of client IDs.
/// Constructing arrays requires garbage collected allocations. This override is only recommended
/// if you either have no strict performance requirements, or have the group of client IDs cached so
/// it is not created each time.
/// </summary>
/// <param name="excludedClientIds"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Not(ulong[] excludedClientIds, RpcTargetUse use)
{
return Not(new NativeArray<ulong>(excludedClientIds, Allocator.Temp), use);
}
/// <summary>
/// Sends to everyone EXCEPT a group of client IDs.
/// This accepts any IEnumerable type, such as List&lt;ulong&gt;, but cannot be called without
/// a garbage collected allocation (even if the type itself is a struct type, due to boxing).
/// This override is only recommended if you either have no strict performance requirements,
/// or have the group of client IDs cached so it is not created each time.
/// </summary>
/// <param name="excludedClientIds"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Not<T>(T excludedClientIds, RpcTargetUse use) where T : IEnumerable<ulong>
{
IGroupRpcTarget target;
if (m_NetworkManager.IsServer)
{
if (use == RpcTargetUse.Persistent)
{
target = new RpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedTargetGroup;
}
}
else
{
if (use == RpcTargetUse.Persistent)
{
target = new ProxyRpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedProxyRpcTargetGroup;
}
}
target.Clear();
using var asASet = new NativeHashSet<ulong>(m_NetworkManager.ConnectedClientsIds.Count, Allocator.Temp);
foreach (var clientId in excludedClientIds)
{
asASet.Add(clientId);
}
foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
{
if (!asASet.Contains(clientId))
{
target.Add(clientId);
}
}
// If ServerIsHost, ConnectedClientIds already contains ServerClientId and this would duplicate it.
if (!m_NetworkManager.ServerIsHost && !asASet.Contains(NetworkManager.ServerClientId))
{
target.Add(NetworkManager.ServerClientId);
}
return target.Target;
}
private ProxyRpcTargetGroup m_CachedProxyRpcTargetGroup;
private RpcTargetGroup m_CachedTargetGroup;
private DirectSendRpcTarget m_CachedDirectSendTarget;
private ProxyRpcTarget m_CachedProxyRpcTarget;
}
}

3
Runtime/Messaging/RpcTargets/RpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 1b26d0227e71408b918ae25ca2a0179b
timeCreated: 1699555535

80
Runtime/Messaging/RpcTargets/RpcTargetGroup.cs Normal file
View File

@@ -0,0 +1,80 @@
using System.Collections.Generic;
namespace Unity.Netcode
{
internal class RpcTargetGroup : BaseRpcTarget, IGroupRpcTarget
{
public BaseRpcTarget Target => this;
internal List<BaseRpcTarget> Targets = new List<BaseRpcTarget>();
private LocalSendRpcTarget m_LocalSendRpcTarget;
private HashSet<ulong> m_Ids = new HashSet<ulong>();
private Stack<DirectSendRpcTarget> m_TargetCache = new Stack<DirectSendRpcTarget>();
public override void Dispose()
{
CheckLockBeforeDispose();
foreach (var target in Targets)
{
target.Dispose();
}
foreach (var target in m_TargetCache)
{
target.Dispose();
}
m_LocalSendRpcTarget.Dispose();
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
foreach (var target in Targets)
{
target.Send(behaviour, ref message, delivery, rpcParams);
}
}
public void Add(ulong clientId)
{
if (!m_Ids.Contains(clientId))
{
m_Ids.Add(clientId);
if (clientId == m_NetworkManager.LocalClientId)
{
Targets.Add(m_LocalSendRpcTarget);
}
else
{
if (m_TargetCache.Count == 0)
{
Targets.Add(new DirectSendRpcTarget(m_NetworkManager) { ClientId = clientId });
}
else
{
var target = m_TargetCache.Pop();
target.ClientId = clientId;
Targets.Add(target);
}
}
}
}
public void Clear()
{
m_Ids.Clear();
foreach (var target in Targets)
{
if (target is DirectSendRpcTarget directSendRpcTarget)
{
m_TargetCache.Push(directSendRpcTarget);
}
}
Targets.Clear();
}
internal RpcTargetGroup(NetworkManager manager) : base(manager)
{
m_LocalSendRpcTarget = new LocalSendRpcTarget(manager);
}
}
}

3
Runtime/Messaging/RpcTargets/RpcTargetGroup.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 7f8c0fc053b64a588c99dd7d706d9f0a
timeCreated: 1697824991

36
Runtime/Messaging/RpcTargets/ServerRpcTarget.cs Normal file
View File

@@ -0,0 +1,36 @@
namespace Unity.Netcode
{
internal class ServerRpcTarget : BaseRpcTarget
{
private BaseRpcTarget m_UnderlyingTarget;
public override void Dispose()
{
if (m_UnderlyingTarget != null)
{
m_UnderlyingTarget.Dispose();
m_UnderlyingTarget = null;
}
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
if (m_UnderlyingTarget == null)
{
if (behaviour.NetworkManager.IsServer)
{
m_UnderlyingTarget = new LocalSendRpcTarget(m_NetworkManager);
}
else
{
m_UnderlyingTarget = new DirectSendRpcTarget(m_NetworkManager) { ClientId = NetworkManager.ServerClientId };
}
}
m_UnderlyingTarget.Send(behaviour, ref message, delivery, rpcParams);
}
internal ServerRpcTarget(NetworkManager manager) : base(manager)
{
}
}
}

3
Runtime/Messaging/RpcTargets/ServerRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: c911725afb6d44f3bb1a1d567d9dee0f
timeCreated: 1697824979