Compare commits
3 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
158f26b913 | ||
|
|
f8ebf679ec | ||
|
|
07f206ff9e |
84
CHANGELOG.md
84
CHANGELOG.md
@@ -6,6 +6,86 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
|
||||
|
||||
Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).
|
||||
|
||||
## [1.9.1] - 2024-04-18
|
||||
|
||||
### Added
|
||||
- Added AnticipatedNetworkVariable<T>, which adds support for client anticipation of NetworkVariable values, allowing for more responsive gameplay (#2820)
|
||||
- Added AnticipatedNetworkTransform, which adds support for client anticipation of NetworkTransforms (#2820)
|
||||
- Added NetworkVariableBase.ExceedsDirtinessThreshold to allow network variables to throttle updates by only sending updates when the difference between the current and previous values exceeds a threshold. (This is exposed in NetworkVariable<T> with the callback NetworkVariable<T>.CheckExceedsDirtinessThreshold) (#2820)
|
||||
- Added NetworkVariableUpdateTraits, which add additional throttling support: MinSecondsBetweenUpdates will prevent the NetworkVariable from sending updates more often than the specified time period (even if it exceeds the dirtiness threshold), while MaxSecondsBetweenUpdates will force a dirty NetworkVariable to send an update after the specified time period even if it has not yet exceeded the dirtiness threshold. (#2820)
|
||||
- Added virtual method NetworkVariableBase.OnInitialize() which can be used by NetworkVariable subclasses to add initialization code (#2820)
|
||||
- Added virtual method NetworkVariableBase.Update(), which is called once per frame to support behaviors such as interpolation between an anticipated value and an authoritative one. (#2820)
|
||||
- Added NetworkTime.TickWithPartial, which represents the current tick as a double that includes the fractional/partial tick value. (#2820)
|
||||
- Added NetworkTickSystem.AnticipationTick, which can be helpful with implementation of client anticipation. This value represents the tick the current local client was at at the beginning of the most recent network round trip, which enables it to correlate server update ticks with the client tick that may have triggered them. (#2820)
|
||||
- `NetworkVariable` now includes built-in support for `NativeHashSet`, `NativeHashMap`, `List`, `HashSet`, and `Dictionary` (#2813)
|
||||
- `NetworkVariable` now includes delta compression for collection values (`NativeList`, `NativeArray`, `NativeHashSet`, `NativeHashMap`, `List`, `HashSet`, `Dictionary`, and `FixedString` types) to save bandwidth by only sending the values that changed. (Note: For `NativeList`, `NativeArray`, and `List`, this algorithm works differently than that used in `NetworkList`. This algorithm will use less bandwidth for "set" and "add" operations, but `NetworkList` is more bandwidth-efficient if you are performing frequent "insert" operations.) (#2813)
|
||||
- `UserNetworkVariableSerialization` now has optional callbacks for `WriteDelta` and `ReadDelta`. If both are provided, they will be used for all serialization operations on NetworkVariables of that type except for the first one for each client. If either is missing, the existing `Write` and `Read` will always be used. (#2813)
|
||||
- Network variables wrapping `INetworkSerializable` types can perform delta serialization by setting `UserNetworkVariableSerialization<T>.WriteDelta` and `UserNetworkVariableSerialization<T>.ReadDelta` for those types. The built-in `INetworkSerializable` serializer will continue to be used for all other serialization operations, but if those callbacks are set, it will call into them on all but the initial serialization to perform delta serialization. (This could be useful if you have a large struct where most values do not change regularly and you want to send only the fields that did change.) (#2813)
|
||||
|
||||
### Fixed
|
||||
|
||||
- Fixed issue where NetworkTransformEditor would throw and exception if you excluded the physics package. (#2871)
|
||||
- Fixed issue where `NetworkTransform` could not properly synchronize its base position when using half float precision. (#2845)
|
||||
- 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 `NetworkObjectReference` and `NetworkBehaviourReference` to allow null references when constructing and serializing. (#2874)
|
||||
- Changed `NetworkAnimator` no longer requires the `Animator` component to exist on the same `GameObject`. (#2872)
|
||||
- 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)
|
||||
|
||||
## [1.8.1] - 2024-02-05
|
||||
|
||||
### Fixed
|
||||
|
||||
- Fixed a compile error when compiling for IL2CPP targets when using the new `[Rpc]` attribute. (#2824)
|
||||
|
||||
## [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)
|
||||
|
||||
## [1.7.1] - 2023-11-15
|
||||
|
||||
### Added
|
||||
@@ -15,8 +95,6 @@ Additional documentation and release notes are available at [Multiplayer Documen
|
||||
- Fixed a bug where having a class with Rpcs that inherits from a class without Rpcs that inherits from NetworkVariable would cause a compile error. (#2751)
|
||||
- Fixed issue where `NetworkBehaviour.Synchronize` was not truncating the write buffer if nothing was serialized during `NetworkBehaviour.OnSynchronize` causing an additional 6 bytes to be written per `NetworkBehaviour` component instance. (#2749)
|
||||
|
||||
### Changed
|
||||
|
||||
## [1.7.0] - 2023-10-11
|
||||
|
||||
### Added
|
||||
@@ -74,7 +152,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
|
||||
### Added
|
||||
|
||||
### Fixed
|
||||
|
||||
- Bumped minimum Unity version supported to 2021.3 LTS
|
||||
- Fixed issue where `NetworkClient.OwnedObjects` was not returning any owned objects due to the `NetworkClient.IsConnected` not being properly set. (#2631)
|
||||
- Fixed a crash when calling TrySetParent with a null Transform (#2625)
|
||||
- Fixed issue where a `NetworkTransform` using full precision state updates was losing transform state updates when interpolation was enabled. (#2624)
|
||||
|
||||
500
Components/AnticipatedNetworkTransform.cs
Normal file
500
Components/AnticipatedNetworkTransform.cs
Normal file
@@ -0,0 +1,500 @@
|
||||
using Unity.Mathematics;
|
||||
using UnityEngine;
|
||||
|
||||
namespace Unity.Netcode.Components
|
||||
{
|
||||
|
||||
#pragma warning disable IDE0001
|
||||
/// <summary>
|
||||
/// A subclass of <see cref="NetworkTransform"/> that supports basic client anticipation - the client
|
||||
/// can set a value on the belief that the server will update it to reflect the same value in a future update
|
||||
/// (i.e., as the result of an RPC call). This value can then be adjusted as new updates from the server come in,
|
||||
/// in three basic modes:
|
||||
///
|
||||
/// <list type="bullet">
|
||||
///
|
||||
/// <item><b>Snap:</b> In this mode (with <see cref="StaleDataHandling"/> set to
|
||||
/// <see cref="StaleDataHandling.Ignore"/> and no <see cref="NetworkBehaviour.OnReanticipate"/> callback),
|
||||
/// the moment a more up-to-date value is received from the authority, it will simply replace the anticipated value,
|
||||
/// resulting in a "snap" to the new value if it is different from the anticipated value.</item>
|
||||
///
|
||||
/// <item><b>Smooth:</b> In this mode (with <see cref="StaleDataHandling"/> set to
|
||||
/// <see cref="Netcode.StaleDataHandling.Ignore"/> and an <see cref="NetworkBehaviour.OnReanticipate"/> callback that calls
|
||||
/// <see cref="Smooth"/> from the anticipated value to the authority value with an appropriate
|
||||
/// <see cref="Mathf.Lerp"/>-style smooth function), when a more up-to-date value is received from the authority,
|
||||
/// it will interpolate over time from an incorrect anticipated value to the correct authoritative value.</item>
|
||||
///
|
||||
/// <item><b>Constant Reanticipation:</b> In this mode (with <see cref="StaleDataHandling"/> set to
|
||||
/// <see cref="Netcode.StaleDataHandling.Reanticipate"/> and an <see cref="NetworkBehaviour.OnReanticipate"/> that calculates a
|
||||
/// new anticipated value based on the current authoritative value), when a more up-to-date value is received from
|
||||
/// the authority, user code calculates a new anticipated value, possibly calling <see cref="Smooth"/> to interpolate
|
||||
/// between the previous anticipation and the new anticipation. This is useful for values that change frequently and
|
||||
/// need to constantly be re-evaluated, as opposed to values that change only in response to user action and simply
|
||||
/// need a one-time anticipation when the user performs that action.</item>
|
||||
///
|
||||
/// </list>
|
||||
///
|
||||
/// Note that these three modes may be combined. For example, if an <see cref="NetworkBehaviour.OnReanticipate"/> callback
|
||||
/// does not call either <see cref="Smooth"/> or one of the Anticipate methods, the result will be a snap to the
|
||||
/// authoritative value, enabling for a callback that may conditionally call <see cref="Smooth"/> when the
|
||||
/// difference between the anticipated and authoritative values is within some threshold, but fall back to
|
||||
/// snap behavior if the difference is too large.
|
||||
/// </summary>
|
||||
#pragma warning restore IDE0001
|
||||
[DisallowMultipleComponent]
|
||||
[AddComponentMenu("Netcode/Anticipated Network Transform")]
|
||||
[DefaultExecutionOrder(100000)] // this is needed to catch the update time after the transform was updated by user scripts
|
||||
public class AnticipatedNetworkTransform : NetworkTransform
|
||||
{
|
||||
public struct TransformState
|
||||
{
|
||||
public Vector3 Position;
|
||||
public Quaternion Rotation;
|
||||
public Vector3 Scale;
|
||||
}
|
||||
|
||||
private TransformState m_AuthoritativeTransform = new TransformState();
|
||||
private TransformState m_AnticipatedTransform = new TransformState();
|
||||
private TransformState m_PreviousAnticipatedTransform = new TransformState();
|
||||
private ulong m_LastAnticipaionCounter;
|
||||
private double m_LastAnticipationTime;
|
||||
private ulong m_LastAuthorityUpdateCounter;
|
||||
|
||||
private TransformState m_SmoothFrom;
|
||||
private TransformState m_SmoothTo;
|
||||
private float m_SmoothDuration;
|
||||
private float m_CurrentSmoothTime;
|
||||
|
||||
private bool m_OutstandingAuthorityChange = false;
|
||||
|
||||
#if UNITY_EDITOR
|
||||
private void Reset()
|
||||
{
|
||||
// Anticipation + smoothing is a form of interpolation, and adding NetworkTransform's buffered interpolation
|
||||
// makes the anticipation get weird, so we default it to false.
|
||||
Interpolate = false;
|
||||
}
|
||||
#endif
|
||||
|
||||
#pragma warning disable IDE0001
|
||||
/// <summary>
|
||||
/// Defines what the behavior should be if we receive a value from the server with an earlier associated
|
||||
/// time value than the anticipation time value.
|
||||
/// <br/><br/>
|
||||
/// If this is <see cref="Netcode.StaleDataHandling.Ignore"/>, the stale data will be ignored and the authoritative
|
||||
/// value will not replace the anticipated value until the anticipation time is reached. <see cref="OnAuthoritativeValueChanged"/>
|
||||
/// and <see cref="OnReanticipate"/> will also not be invoked for this stale data.
|
||||
/// <br/><br/>
|
||||
/// If this is <see cref="Netcode.StaleDataHandling.Reanticipate"/>, the stale data will replace the anticipated data and
|
||||
/// <see cref="OnAuthoritativeValueChanged"/> and <see cref="OnReanticipate"/> will be invoked.
|
||||
/// In this case, the authoritativeTime value passed to <see cref="OnReanticipate"/> will be lower than
|
||||
/// the anticipationTime value, and that callback can be used to calculate a new anticipated value.
|
||||
/// </summary>
|
||||
#pragma warning restore IDE0001
|
||||
public StaleDataHandling StaleDataHandling = StaleDataHandling.Reanticipate;
|
||||
|
||||
/// <summary>
|
||||
/// Contains the current state of this transform on the server side.
|
||||
/// Note that, on the server side, this gets updated at the end of the frame, and will not immediately reflect
|
||||
/// changes to the transform.
|
||||
/// </summary>
|
||||
public TransformState AuthoritativeState => m_AuthoritativeTransform;
|
||||
|
||||
/// <summary>
|
||||
/// Contains the current anticipated state, which will match the values of this object's
|
||||
/// actual <see cref="MonoBehaviour.transform"/>. When a server
|
||||
/// update arrives, this value will be overwritten by the new
|
||||
/// server value (unless stale data handling is set to "Ignore"
|
||||
/// and the update is determined to be stale). This value will
|
||||
/// be duplicated in <see cref="PreviousAnticipatedState"/>, which
|
||||
/// will NOT be overwritten in server updates.
|
||||
/// </summary>
|
||||
public TransformState AnticipatedState => m_AnticipatedTransform;
|
||||
|
||||
/// <summary>
|
||||
/// Indicates whether this transform currently needs
|
||||
/// reanticipation. If this is true, the anticipated value
|
||||
/// has been overwritten by the authoritative value from the
|
||||
/// server; the previous anticipated value is stored in <see cref="PreviousAnticipatedState"/>
|
||||
/// </summary>
|
||||
public bool ShouldReanticipate
|
||||
{
|
||||
get;
|
||||
private set;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Holds the most recent anticipated state, whatever was
|
||||
/// most recently set using the Anticipate methods. Unlike
|
||||
/// <see cref="AnticipatedState"/>, this does not get overwritten
|
||||
/// when a server update arrives.
|
||||
/// </summary>
|
||||
public TransformState PreviousAnticipatedState => m_PreviousAnticipatedTransform;
|
||||
|
||||
/// <summary>
|
||||
/// Anticipate that, at the end of one round trip to the server, this transform will be in the given
|
||||
/// <see cref="newPosition"/>
|
||||
/// </summary>
|
||||
/// <param name="newPosition"></param>
|
||||
public void AnticipateMove(Vector3 newPosition)
|
||||
{
|
||||
if (NetworkManager.ShutdownInProgress || !NetworkManager.IsListening)
|
||||
{
|
||||
return;
|
||||
}
|
||||
transform.position = newPosition;
|
||||
m_AnticipatedTransform.Position = newPosition;
|
||||
if (CanCommitToTransform)
|
||||
{
|
||||
m_AuthoritativeTransform.Position = newPosition;
|
||||
}
|
||||
|
||||
m_PreviousAnticipatedTransform = m_AnticipatedTransform;
|
||||
|
||||
m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
|
||||
m_LastAnticipationTime = NetworkManager.LocalTime.Time;
|
||||
|
||||
m_SmoothDuration = 0;
|
||||
m_CurrentSmoothTime = 0;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Anticipate that, at the end of one round trip to the server, this transform will have the given
|
||||
/// <see cref="newRotation"/>
|
||||
/// </summary>
|
||||
/// <param name="newRotation"></param>
|
||||
public void AnticipateRotate(Quaternion newRotation)
|
||||
{
|
||||
if (NetworkManager.ShutdownInProgress || !NetworkManager.IsListening)
|
||||
{
|
||||
return;
|
||||
}
|
||||
transform.rotation = newRotation;
|
||||
m_AnticipatedTransform.Rotation = newRotation;
|
||||
if (CanCommitToTransform)
|
||||
{
|
||||
m_AuthoritativeTransform.Rotation = newRotation;
|
||||
}
|
||||
|
||||
m_PreviousAnticipatedTransform = m_AnticipatedTransform;
|
||||
|
||||
m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
|
||||
m_LastAnticipationTime = NetworkManager.LocalTime.Time;
|
||||
|
||||
m_SmoothDuration = 0;
|
||||
m_CurrentSmoothTime = 0;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Anticipate that, at the end of one round trip to the server, this transform will have the given
|
||||
/// <see cref="newScale"/>
|
||||
/// </summary>
|
||||
/// <param name="newScale"></param>
|
||||
public void AnticipateScale(Vector3 newScale)
|
||||
{
|
||||
if (NetworkManager.ShutdownInProgress || !NetworkManager.IsListening)
|
||||
{
|
||||
return;
|
||||
}
|
||||
transform.localScale = newScale;
|
||||
m_AnticipatedTransform.Scale = newScale;
|
||||
if (CanCommitToTransform)
|
||||
{
|
||||
m_AuthoritativeTransform.Scale = newScale;
|
||||
}
|
||||
|
||||
m_PreviousAnticipatedTransform = m_AnticipatedTransform;
|
||||
|
||||
m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
|
||||
m_LastAnticipationTime = NetworkManager.LocalTime.Time;
|
||||
|
||||
m_SmoothDuration = 0;
|
||||
m_CurrentSmoothTime = 0;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Anticipate that, at the end of one round trip to the server, the transform will have the given
|
||||
/// <see cref="newState"/>
|
||||
/// </summary>
|
||||
/// <param name="newState"></param>
|
||||
public void AnticipateState(TransformState newState)
|
||||
{
|
||||
if (NetworkManager.ShutdownInProgress || !NetworkManager.IsListening)
|
||||
{
|
||||
return;
|
||||
}
|
||||
var transform_ = transform;
|
||||
transform_.position = newState.Position;
|
||||
transform_.rotation = newState.Rotation;
|
||||
transform_.localScale = newState.Scale;
|
||||
m_AnticipatedTransform = newState;
|
||||
if (CanCommitToTransform)
|
||||
{
|
||||
m_AuthoritativeTransform = newState;
|
||||
}
|
||||
|
||||
m_PreviousAnticipatedTransform = m_AnticipatedTransform;
|
||||
|
||||
m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
|
||||
m_LastAnticipationTime = NetworkManager.LocalTime.Time;
|
||||
|
||||
m_SmoothDuration = 0;
|
||||
m_CurrentSmoothTime = 0;
|
||||
}
|
||||
|
||||
protected override void Update()
|
||||
{
|
||||
// If not spawned or this instance has authority, exit early
|
||||
if (!IsSpawned)
|
||||
{
|
||||
return;
|
||||
}
|
||||
// Do not call the base class implementation...
|
||||
// AnticipatedNetworkTransform applies its authoritative state immediately rather than waiting for update
|
||||
// This is because AnticipatedNetworkTransforms may need to reference each other in reanticipating
|
||||
// and we will want all reanticipation done before anything else wants to reference the transform in
|
||||
// Update()
|
||||
//base.Update();
|
||||
|
||||
if (m_CurrentSmoothTime < m_SmoothDuration)
|
||||
{
|
||||
m_CurrentSmoothTime += NetworkManager.RealTimeProvider.DeltaTime;
|
||||
var transform_ = transform;
|
||||
var pct = math.min(m_CurrentSmoothTime / m_SmoothDuration, 1f);
|
||||
|
||||
m_AnticipatedTransform = new TransformState
|
||||
{
|
||||
Position = Vector3.Lerp(m_SmoothFrom.Position, m_SmoothTo.Position, pct),
|
||||
Rotation = Quaternion.Slerp(m_SmoothFrom.Rotation, m_SmoothTo.Rotation, pct),
|
||||
Scale = Vector3.Lerp(m_SmoothFrom.Scale, m_SmoothTo.Scale, pct)
|
||||
};
|
||||
m_PreviousAnticipatedTransform = m_AnticipatedTransform;
|
||||
if (!CanCommitToTransform)
|
||||
{
|
||||
transform_.position = m_AnticipatedTransform.Position;
|
||||
transform_.localScale = m_AnticipatedTransform.Scale;
|
||||
transform_.rotation = m_AnticipatedTransform.Rotation;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
internal class AnticipatedObject : IAnticipationEventReceiver, IAnticipatedObject
|
||||
{
|
||||
public AnticipatedNetworkTransform Transform;
|
||||
|
||||
|
||||
public void SetupForRender()
|
||||
{
|
||||
if (Transform.CanCommitToTransform)
|
||||
{
|
||||
var transform_ = Transform.transform;
|
||||
Transform.m_AuthoritativeTransform = new TransformState
|
||||
{
|
||||
Position = transform_.position,
|
||||
Rotation = transform_.rotation,
|
||||
Scale = transform_.localScale
|
||||
};
|
||||
if (Transform.m_CurrentSmoothTime >= Transform.m_SmoothDuration)
|
||||
{
|
||||
// If we've had a call to Smooth() we'll continue interpolating.
|
||||
// Otherwise we'll go ahead and make the visual and actual locations
|
||||
// match.
|
||||
Transform.m_AnticipatedTransform = Transform.m_AuthoritativeTransform;
|
||||
}
|
||||
|
||||
transform_.position = Transform.m_AnticipatedTransform.Position;
|
||||
transform_.rotation = Transform.m_AnticipatedTransform.Rotation;
|
||||
transform_.localScale = Transform.m_AnticipatedTransform.Scale;
|
||||
}
|
||||
}
|
||||
|
||||
public void SetupForUpdate()
|
||||
{
|
||||
if (Transform.CanCommitToTransform)
|
||||
{
|
||||
var transform_ = Transform.transform;
|
||||
transform_.position = Transform.m_AuthoritativeTransform.Position;
|
||||
transform_.rotation = Transform.m_AuthoritativeTransform.Rotation;
|
||||
transform_.localScale = Transform.m_AuthoritativeTransform.Scale;
|
||||
}
|
||||
}
|
||||
|
||||
public void Update()
|
||||
{
|
||||
// No need to do this, it's handled by NetworkBehaviour.Update
|
||||
}
|
||||
|
||||
public void ResetAnticipation()
|
||||
{
|
||||
Transform.ShouldReanticipate = false;
|
||||
}
|
||||
|
||||
public NetworkObject OwnerObject => Transform.NetworkObject;
|
||||
}
|
||||
|
||||
private AnticipatedObject m_AnticipatedObject = null;
|
||||
|
||||
private void ResetAnticipatedState()
|
||||
{
|
||||
var transform_ = transform;
|
||||
m_AuthoritativeTransform = new TransformState
|
||||
{
|
||||
Position = transform_.position,
|
||||
Rotation = transform_.rotation,
|
||||
Scale = transform_.localScale
|
||||
};
|
||||
m_AnticipatedTransform = m_AuthoritativeTransform;
|
||||
m_PreviousAnticipatedTransform = m_AnticipatedTransform;
|
||||
|
||||
m_SmoothDuration = 0;
|
||||
m_CurrentSmoothTime = 0;
|
||||
}
|
||||
|
||||
protected override void OnSynchronize<T>(ref BufferSerializer<T> serializer)
|
||||
{
|
||||
base.OnSynchronize(ref serializer);
|
||||
if (!CanCommitToTransform)
|
||||
{
|
||||
m_OutstandingAuthorityChange = true;
|
||||
ApplyAuthoritativeState();
|
||||
ResetAnticipatedState();
|
||||
}
|
||||
}
|
||||
|
||||
public override void OnNetworkSpawn()
|
||||
{
|
||||
base.OnNetworkSpawn();
|
||||
m_OutstandingAuthorityChange = true;
|
||||
ApplyAuthoritativeState();
|
||||
ResetAnticipatedState();
|
||||
|
||||
m_AnticipatedObject = new AnticipatedObject { Transform = this };
|
||||
NetworkManager.AnticipationSystem.RegisterForAnticipationEvents(m_AnticipatedObject);
|
||||
NetworkManager.AnticipationSystem.AllAnticipatedObjects.Add(m_AnticipatedObject);
|
||||
}
|
||||
|
||||
public override void OnNetworkDespawn()
|
||||
{
|
||||
if (m_AnticipatedObject != null)
|
||||
{
|
||||
NetworkManager.AnticipationSystem.DeregisterForAnticipationEvents(m_AnticipatedObject);
|
||||
NetworkManager.AnticipationSystem.AllAnticipatedObjects.Remove(m_AnticipatedObject);
|
||||
NetworkManager.AnticipationSystem.ObjectsToReanticipate.Remove(m_AnticipatedObject);
|
||||
m_AnticipatedObject = null;
|
||||
}
|
||||
ResetAnticipatedState();
|
||||
|
||||
base.OnNetworkDespawn();
|
||||
}
|
||||
|
||||
public override void OnDestroy()
|
||||
{
|
||||
if (m_AnticipatedObject != null)
|
||||
{
|
||||
NetworkManager.AnticipationSystem.DeregisterForAnticipationEvents(m_AnticipatedObject);
|
||||
NetworkManager.AnticipationSystem.AllAnticipatedObjects.Remove(m_AnticipatedObject);
|
||||
NetworkManager.AnticipationSystem.ObjectsToReanticipate.Remove(m_AnticipatedObject);
|
||||
m_AnticipatedObject = null;
|
||||
}
|
||||
|
||||
base.OnDestroy();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Interpolate between the transform represented by <see cref="from"/> to the transform represented by
|
||||
/// <see cref="to"/> over <see cref="durationSeconds"/> of real time. The duration uses
|
||||
/// <see cref="Time.deltaTime"/>, so it is affected by <see cref="Time.timeScale"/>.
|
||||
/// </summary>
|
||||
/// <param name="from"></param>
|
||||
/// <param name="to"></param>
|
||||
/// <param name="durationSeconds"></param>
|
||||
public void Smooth(TransformState from, TransformState to, float durationSeconds)
|
||||
{
|
||||
var transform_ = transform;
|
||||
if (durationSeconds <= 0)
|
||||
{
|
||||
m_AnticipatedTransform = to;
|
||||
m_PreviousAnticipatedTransform = m_AnticipatedTransform;
|
||||
transform_.position = to.Position;
|
||||
transform_.rotation = to.Rotation;
|
||||
transform_.localScale = to.Scale;
|
||||
m_SmoothDuration = 0;
|
||||
m_CurrentSmoothTime = 0;
|
||||
return;
|
||||
}
|
||||
m_AnticipatedTransform = from;
|
||||
m_PreviousAnticipatedTransform = m_AnticipatedTransform;
|
||||
|
||||
if (!CanCommitToTransform)
|
||||
{
|
||||
transform_.position = from.Position;
|
||||
transform_.rotation = from.Rotation;
|
||||
transform_.localScale = from.Scale;
|
||||
}
|
||||
|
||||
m_SmoothFrom = from;
|
||||
m_SmoothTo = to;
|
||||
m_SmoothDuration = durationSeconds;
|
||||
m_CurrentSmoothTime = 0;
|
||||
}
|
||||
|
||||
protected override void OnBeforeUpdateTransformState()
|
||||
{
|
||||
// this is called when new data comes from the server
|
||||
m_LastAuthorityUpdateCounter = NetworkManager.AnticipationSystem.LastAnticipationAck;
|
||||
m_OutstandingAuthorityChange = true;
|
||||
}
|
||||
|
||||
protected override void OnNetworkTransformStateUpdated(ref NetworkTransformState oldState, ref NetworkTransformState newState)
|
||||
{
|
||||
base.OnNetworkTransformStateUpdated(ref oldState, ref newState);
|
||||
ApplyAuthoritativeState();
|
||||
}
|
||||
|
||||
protected override void OnTransformUpdated()
|
||||
{
|
||||
if (CanCommitToTransform || m_AnticipatedObject == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
// this is called pretty much every frame and will change the transform
|
||||
// If we've overridden the transform with an anticipated state, we need to be able to change it back
|
||||
// to the anticipated state (while updating the authority state accordingly) or else
|
||||
// mark this transform for reanticipation
|
||||
var transform_ = transform;
|
||||
|
||||
var previousAnticipatedTransform = m_AnticipatedTransform;
|
||||
|
||||
// Update authority state to catch any possible interpolation data
|
||||
m_AuthoritativeTransform.Position = transform_.position;
|
||||
m_AuthoritativeTransform.Rotation = transform_.rotation;
|
||||
m_AuthoritativeTransform.Scale = transform_.localScale;
|
||||
|
||||
if (!m_OutstandingAuthorityChange)
|
||||
{
|
||||
// Keep the anticipated value unchanged, we have no updates from the server at all.
|
||||
transform_.position = previousAnticipatedTransform.Position;
|
||||
transform_.localScale = previousAnticipatedTransform.Scale;
|
||||
transform_.rotation = previousAnticipatedTransform.Rotation;
|
||||
return;
|
||||
}
|
||||
|
||||
if (StaleDataHandling == StaleDataHandling.Ignore && m_LastAnticipaionCounter > m_LastAuthorityUpdateCounter)
|
||||
{
|
||||
// Keep the anticipated value unchanged because it is more recent than the authoritative one.
|
||||
transform_.position = previousAnticipatedTransform.Position;
|
||||
transform_.localScale = previousAnticipatedTransform.Scale;
|
||||
transform_.rotation = previousAnticipatedTransform.Rotation;
|
||||
return;
|
||||
}
|
||||
|
||||
m_SmoothDuration = 0;
|
||||
m_CurrentSmoothTime = 0;
|
||||
m_OutstandingAuthorityChange = false;
|
||||
m_AnticipatedTransform = m_AuthoritativeTransform;
|
||||
|
||||
ShouldReanticipate = true;
|
||||
NetworkManager.AnticipationSystem.ObjectsToReanticipate.Add(m_AnticipatedObject);
|
||||
}
|
||||
}
|
||||
}
|
||||
3
Components/AnticipatedNetworkTransform.cs.meta
Normal file
3
Components/AnticipatedNetworkTransform.cs.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 97616b67982a4be48d957d421e422433
|
||||
timeCreated: 1705597211
|
||||
8
Components/Messages.meta
Normal file
8
Components/Messages.meta
Normal file
@@ -0,0 +1,8 @@
|
||||
fileFormatVersion: 2
|
||||
guid: a9db1d18fa0117f4da5e8e65386b894a
|
||||
folderAsset: yes
|
||||
DefaultImporter:
|
||||
externalObjects: {}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
116
Components/Messages/NetworkTransformMessage.cs
Normal file
116
Components/Messages/NetworkTransformMessage.cs
Normal file
@@ -0,0 +1,116 @@
|
||||
using Unity.Netcode.Components;
|
||||
using UnityEngine;
|
||||
|
||||
namespace Unity.Netcode
|
||||
{
|
||||
/// <summary>
|
||||
/// NetworkTransform State Update Message
|
||||
/// </summary>
|
||||
internal struct NetworkTransformMessage : INetworkMessage
|
||||
{
|
||||
public int Version => 0;
|
||||
public ulong NetworkObjectId;
|
||||
public int NetworkBehaviourId;
|
||||
public NetworkTransform.NetworkTransformState State;
|
||||
|
||||
private NetworkTransform m_ReceiverNetworkTransform;
|
||||
private FastBufferReader m_CurrentReader;
|
||||
|
||||
private unsafe void CopyPayload(ref FastBufferWriter writer)
|
||||
{
|
||||
writer.WriteBytesSafe(m_CurrentReader.GetUnsafePtrAtCurrentPosition(), m_CurrentReader.Length - m_CurrentReader.Position);
|
||||
}
|
||||
|
||||
public void Serialize(FastBufferWriter writer, int targetVersion)
|
||||
{
|
||||
if (m_CurrentReader.IsInitialized)
|
||||
{
|
||||
CopyPayload(ref writer);
|
||||
}
|
||||
else
|
||||
{
|
||||
BytePacker.WriteValueBitPacked(writer, NetworkObjectId);
|
||||
BytePacker.WriteValueBitPacked(writer, NetworkBehaviourId);
|
||||
writer.WriteNetworkSerializable(State);
|
||||
}
|
||||
}
|
||||
|
||||
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
|
||||
{
|
||||
var networkManager = context.SystemOwner as NetworkManager;
|
||||
if (networkManager == null)
|
||||
{
|
||||
Debug.LogError($"[{nameof(NetworkTransformMessage)}] System owner context was not of type {nameof(NetworkManager)}!");
|
||||
return false;
|
||||
}
|
||||
var currentPosition = reader.Position;
|
||||
ByteUnpacker.ReadValueBitPacked(reader, out NetworkObjectId);
|
||||
if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
|
||||
{
|
||||
networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
|
||||
return false;
|
||||
}
|
||||
// Get the behaviour index
|
||||
ByteUnpacker.ReadValueBitPacked(reader, out NetworkBehaviourId);
|
||||
|
||||
// Deserialize the state
|
||||
reader.ReadNetworkSerializable(out State);
|
||||
|
||||
var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
|
||||
|
||||
// Get the target NetworkTransform
|
||||
m_ReceiverNetworkTransform = networkObject.ChildNetworkBehaviours[NetworkBehaviourId] as NetworkTransform;
|
||||
|
||||
var isServerAuthoritative = m_ReceiverNetworkTransform.IsServerAuthoritative();
|
||||
var ownerAuthoritativeServerSide = !isServerAuthoritative && networkManager.IsServer;
|
||||
if (ownerAuthoritativeServerSide)
|
||||
{
|
||||
var ownerClientId = networkObject.OwnerClientId;
|
||||
if (ownerClientId == NetworkManager.ServerClientId)
|
||||
{
|
||||
// Ownership must have changed, ignore any additional pending messages that might have
|
||||
// come from a previous owner client.
|
||||
return true;
|
||||
}
|
||||
|
||||
var networkDelivery = State.IsReliableStateUpdate() ? NetworkDelivery.ReliableSequenced : NetworkDelivery.UnreliableSequenced;
|
||||
|
||||
// Forward the state update if there are any remote clients to foward it to
|
||||
if (networkManager.ConnectionManager.ConnectedClientsList.Count > (networkManager.IsHost ? 2 : 1))
|
||||
{
|
||||
// This is only to copy the existing and already serialized struct for forwarding purposes only.
|
||||
// This will not include any changes made to this struct at this particular stage of processing the message.
|
||||
var currentMessage = this;
|
||||
// Create a new reader that replicates this message
|
||||
currentMessage.m_CurrentReader = new FastBufferReader(reader, Collections.Allocator.None);
|
||||
// Rewind the new reader to the beginning of the message's payload
|
||||
currentMessage.m_CurrentReader.Seek(currentPosition);
|
||||
// Forward the message to all connected clients that are observers of the associated NetworkObject
|
||||
var clientCount = networkManager.ConnectionManager.ConnectedClientsList.Count;
|
||||
for (int i = 0; i < clientCount; i++)
|
||||
{
|
||||
var clientId = networkManager.ConnectionManager.ConnectedClientsList[i].ClientId;
|
||||
if (NetworkManager.ServerClientId == clientId || (!isServerAuthoritative && clientId == ownerClientId) || !networkObject.Observers.Contains(clientId))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
networkManager.MessageManager.SendMessage(ref currentMessage, networkDelivery, clientId);
|
||||
}
|
||||
// Dispose of the reader used for forwarding
|
||||
currentMessage.m_CurrentReader.Dispose();
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public void Handle(ref NetworkContext context)
|
||||
{
|
||||
if (m_ReceiverNetworkTransform == null)
|
||||
{
|
||||
Debug.LogError($"[{nameof(NetworkTransformMessage)}][Dropped] Reciever {nameof(NetworkTransform)} was not set!");
|
||||
return;
|
||||
}
|
||||
m_ReceiverNetworkTransform.TransformStateUpdate(ref State);
|
||||
}
|
||||
}
|
||||
}
|
||||
11
Components/Messages/NetworkTransformMessage.cs.meta
Normal file
11
Components/Messages/NetworkTransformMessage.cs.meta
Normal file
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: dcfc8ac43fef97e42adb19b998d70c37
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -164,7 +164,6 @@ namespace Unity.Netcode.Components
|
||||
/// NetworkAnimator enables remote synchronization of <see cref="UnityEngine.Animator"/> state for on network objects.
|
||||
/// </summary>
|
||||
[AddComponentMenu("Netcode/Network Animator")]
|
||||
[RequireComponent(typeof(Animator))]
|
||||
public class NetworkAnimator : NetworkBehaviour, ISerializationCallbackReceiver
|
||||
{
|
||||
[Serializable]
|
||||
@@ -833,8 +832,7 @@ namespace Unity.Netcode.Components
|
||||
stateChangeDetected = true;
|
||||
//Debug.Log($"[Cross-Fade] To-Hash: {nt.fullPathHash} | TI-Duration: ({tt.duration}) | TI-Norm: ({tt.normalizedTime}) | From-Hash: ({m_AnimationHash[layer]}) | SI-FPHash: ({st.fullPathHash}) | SI-Norm: ({st.normalizedTime})");
|
||||
}
|
||||
else
|
||||
if (!tt.anyState && tt.fullPathHash != m_TransitionHash[layer])
|
||||
else if (!tt.anyState && tt.fullPathHash != m_TransitionHash[layer])
|
||||
{
|
||||
// first time in this transition for this layer
|
||||
m_TransitionHash[layer] = tt.fullPathHash;
|
||||
@@ -1053,8 +1051,7 @@ namespace Unity.Netcode.Components
|
||||
BytePacker.WriteValuePacked(writer, valueBool);
|
||||
}
|
||||
}
|
||||
else
|
||||
if (cacheValue.Type == AnimationParamEnumWrapper.AnimatorControllerParameterFloat)
|
||||
else if (cacheValue.Type == AnimationParamEnumWrapper.AnimatorControllerParameterFloat)
|
||||
{
|
||||
var valueFloat = m_Animator.GetFloat(hash);
|
||||
fixed (void* value = cacheValue.Value)
|
||||
|
||||
@@ -23,12 +23,20 @@ namespace Unity.Netcode.Components
|
||||
internal Vector3 DeltaPosition;
|
||||
internal int NetworkTick;
|
||||
|
||||
internal bool SynchronizeBase;
|
||||
|
||||
internal bool CollapsedDeltaIntoBase;
|
||||
|
||||
/// <summary>
|
||||
/// The serialization implementation of <see cref="INetworkSerializable"/>
|
||||
/// </summary>
|
||||
public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
|
||||
{
|
||||
HalfVector3.NetworkSerialize(serializer);
|
||||
if (SynchronizeBase)
|
||||
{
|
||||
serializer.SerializeValue(ref CurrentBasePosition);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -122,6 +130,7 @@ namespace Unity.Netcode.Components
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
public void UpdateFrom(ref Vector3 vector3, int networkTick)
|
||||
{
|
||||
CollapsedDeltaIntoBase = false;
|
||||
NetworkTick = networkTick;
|
||||
DeltaPosition = (vector3 + PrecisionLossDelta) - CurrentBasePosition;
|
||||
for (int i = 0; i < HalfVector3.Length; i++)
|
||||
@@ -136,6 +145,7 @@ namespace Unity.Netcode.Components
|
||||
CurrentBasePosition[i] += HalfDeltaConvertedBack[i];
|
||||
HalfDeltaConvertedBack[i] = 0.0f;
|
||||
DeltaPosition[i] = 0.0f;
|
||||
CollapsedDeltaIntoBase = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -164,6 +174,8 @@ namespace Unity.Netcode.Components
|
||||
DeltaPosition = Vector3.zero;
|
||||
HalfDeltaConvertedBack = Vector3.zero;
|
||||
HalfVector3 = new HalfVector3(vector3, axisToSynchronize);
|
||||
SynchronizeBase = false;
|
||||
CollapsedDeltaIntoBase = false;
|
||||
UpdateFrom(ref vector3, networkTick);
|
||||
}
|
||||
|
||||
|
||||
@@ -29,15 +29,25 @@ namespace Unity.Netcode.Components
|
||||
m_NetworkTransform = GetComponent<NetworkTransform>();
|
||||
m_IsServerAuthoritative = m_NetworkTransform.IsServerAuthoritative();
|
||||
|
||||
SetupRigidBody();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// If the current <see cref="NetworkTransform"/> has authority,
|
||||
/// then use the <see cref="RigidBody"/> interpolation strategy,
|
||||
/// if the <see cref="NetworkTransform"/> is handling interpolation,
|
||||
/// set interpolation to none on the <see cref="RigidBody"/>
|
||||
/// <br/>
|
||||
/// Turn off physics for the rigid body until spawned, otherwise
|
||||
/// clients can run fixed update before the first
|
||||
/// full <see cref="NetworkTransform"/> update
|
||||
/// </summary>
|
||||
private void SetupRigidBody()
|
||||
{
|
||||
m_Rigidbody = GetComponent<Rigidbody>();
|
||||
m_OriginalInterpolation = m_Rigidbody.interpolation;
|
||||
|
||||
// Set interpolation to none if NetworkTransform is handling interpolation, otherwise it sets it to the original value
|
||||
m_Rigidbody.interpolation = m_NetworkTransform.Interpolate ? RigidbodyInterpolation.None : m_OriginalInterpolation;
|
||||
|
||||
// Turn off physics for the rigid body until spawned, otherwise
|
||||
// clients can run fixed update before the first full
|
||||
// NetworkTransform update
|
||||
m_Rigidbody.interpolation = m_IsAuthority ? m_OriginalInterpolation : (m_NetworkTransform.Interpolate ? RigidbodyInterpolation.None : m_OriginalInterpolation);
|
||||
m_Rigidbody.isKinematic = true;
|
||||
}
|
||||
|
||||
|
||||
@@ -30,6 +30,11 @@ namespace Unity.Netcode.Components
|
||||
{
|
||||
m_Rigidbody = GetComponent<Rigidbody2D>();
|
||||
m_NetworkTransform = GetComponent<NetworkTransform>();
|
||||
|
||||
// Turn off physics for the rigid body until spawned, otherwise
|
||||
// clients can run fixed update before the first full
|
||||
// NetworkTransform update
|
||||
m_Rigidbody.isKinematic = true;
|
||||
}
|
||||
|
||||
private void FixedUpdate()
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -16,7 +16,7 @@ See guides below to install Unity Netcode for GameObjects, set up your project,
|
||||
## Requirements
|
||||
|
||||
Netcode for GameObjects targets the following Unity versions:
|
||||
- Unity 2020.3, 2021.1, 2021.2 and 2021.3
|
||||
- Unity 2021.3 (LTS), 2022.3 (LTS) and 2023.2
|
||||
|
||||
On the following runtime platforms:
|
||||
- Windows, MacOS, and Linux
|
||||
|
||||
14
Editor/AnticipatedNetworkTransformEditor.cs
Normal file
14
Editor/AnticipatedNetworkTransformEditor.cs
Normal file
@@ -0,0 +1,14 @@
|
||||
using Unity.Netcode.Components;
|
||||
using UnityEditor;
|
||||
|
||||
namespace Unity.Netcode.Editor
|
||||
{
|
||||
/// <summary>
|
||||
/// The <see cref="CustomEditor"/> for <see cref="AnticipatedNetworkTransform"/>
|
||||
/// </summary>
|
||||
[CustomEditor(typeof(AnticipatedNetworkTransform), true)]
|
||||
public class AnticipatedNetworkTransformEditor : NetworkTransformEditor
|
||||
{
|
||||
public override bool HideInterpolateValue => true;
|
||||
}
|
||||
}
|
||||
3
Editor/AnticipatedNetworkTransformEditor.cs.meta
Normal file
3
Editor/AnticipatedNetworkTransformEditor.cs.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 34bc168605014eeeadf97b12080e11fa
|
||||
timeCreated: 1707514321
|
||||
@@ -21,13 +21,16 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
public const string NetcodeModuleName = "Unity.Netcode.Runtime.dll";
|
||||
|
||||
public const string RuntimeAssemblyName = "Unity.Netcode.Runtime";
|
||||
public const string ComponentsAssemblyName = "Unity.Netcode.Components";
|
||||
|
||||
public static readonly string NetworkBehaviour_FullName = typeof(NetworkBehaviour).FullName;
|
||||
public static readonly string INetworkMessage_FullName = typeof(INetworkMessage).FullName;
|
||||
public static readonly string ServerRpcAttribute_FullName = typeof(ServerRpcAttribute).FullName;
|
||||
public static readonly string ClientRpcAttribute_FullName = typeof(ClientRpcAttribute).FullName;
|
||||
public static readonly string RpcAttribute_FullName = typeof(RpcAttribute).FullName;
|
||||
public static readonly string ServerRpcParams_FullName = typeof(ServerRpcParams).FullName;
|
||||
public static readonly string ClientRpcParams_FullName = typeof(ClientRpcParams).FullName;
|
||||
public static readonly string RpcParams_FullName = typeof(RpcParams).FullName;
|
||||
public static readonly string ClientRpcSendParams_FullName = typeof(ClientRpcSendParams).FullName;
|
||||
public static readonly string ClientRpcReceiveParams_FullName = typeof(ClientRpcReceiveParams).FullName;
|
||||
public static readonly string ServerRpcSendParams_FullName = typeof(ServerRpcSendParams).FullName;
|
||||
|
||||
@@ -17,7 +17,7 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
{
|
||||
public override ILPPInterface GetInstance() => this;
|
||||
|
||||
public override bool WillProcess(ICompiledAssembly compiledAssembly) => compiledAssembly.Name == CodeGenHelpers.RuntimeAssemblyName;
|
||||
public override bool WillProcess(ICompiledAssembly compiledAssembly) => compiledAssembly.Name == CodeGenHelpers.RuntimeAssemblyName || compiledAssembly.Name == CodeGenHelpers.ComponentsAssemblyName;
|
||||
|
||||
private readonly List<DiagnosticMessage> m_Diagnostics = new List<DiagnosticMessage>();
|
||||
|
||||
|
||||
@@ -31,6 +31,43 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
|
||||
private readonly List<DiagnosticMessage> m_Diagnostics = new List<DiagnosticMessage>();
|
||||
|
||||
public void AddWrappedType(TypeReference wrappedType)
|
||||
{
|
||||
if (!m_WrappedNetworkVariableTypes.Contains(wrappedType))
|
||||
{
|
||||
m_WrappedNetworkVariableTypes.Add(wrappedType);
|
||||
|
||||
var resolved = wrappedType.Resolve();
|
||||
if (resolved != null)
|
||||
{
|
||||
if (resolved.FullName == "System.Collections.Generic.List`1")
|
||||
{
|
||||
AddWrappedType(((GenericInstanceType)wrappedType).GenericArguments[0]);
|
||||
}
|
||||
if (resolved.FullName == "System.Collections.Generic.HashSet`1")
|
||||
{
|
||||
AddWrappedType(((GenericInstanceType)wrappedType).GenericArguments[0]);
|
||||
}
|
||||
else if (resolved.FullName == "System.Collections.Generic.Dictionary`2")
|
||||
{
|
||||
AddWrappedType(((GenericInstanceType)wrappedType).GenericArguments[0]);
|
||||
AddWrappedType(((GenericInstanceType)wrappedType).GenericArguments[1]);
|
||||
}
|
||||
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
|
||||
else if (resolved.FullName == "Unity.Collections.NativeHashSet`1")
|
||||
{
|
||||
AddWrappedType(((GenericInstanceType)wrappedType).GenericArguments[0]);
|
||||
}
|
||||
else if (resolved.FullName == "Unity.Collections.NativeHashMap`2")
|
||||
{
|
||||
AddWrappedType(((GenericInstanceType)wrappedType).GenericArguments[0]);
|
||||
AddWrappedType(((GenericInstanceType)wrappedType).GenericArguments[1]);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public override ILPostProcessResult Process(ICompiledAssembly compiledAssembly)
|
||||
{
|
||||
if (!WillProcess(compiledAssembly))
|
||||
@@ -87,10 +124,7 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
if (attribute.AttributeType.Name == nameof(GenerateSerializationForTypeAttribute))
|
||||
{
|
||||
var wrappedType = mainModule.ImportReference((TypeReference)attribute.ConstructorArguments[0].Value);
|
||||
if (!m_WrappedNetworkVariableTypes.Contains(wrappedType))
|
||||
{
|
||||
m_WrappedNetworkVariableTypes.Add(wrappedType);
|
||||
}
|
||||
AddWrappedType(wrappedType);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -101,10 +135,7 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
if (attribute.AttributeType.Name == nameof(GenerateSerializationForTypeAttribute))
|
||||
{
|
||||
var wrappedType = mainModule.ImportReference((TypeReference)attribute.ConstructorArguments[0].Value);
|
||||
if (!m_WrappedNetworkVariableTypes.Contains(wrappedType))
|
||||
{
|
||||
m_WrappedNetworkVariableTypes.Add(wrappedType);
|
||||
}
|
||||
AddWrappedType(wrappedType);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -241,6 +272,36 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
serializeMethod?.GenericArguments.Add(wrappedType);
|
||||
equalityMethod.GenericArguments.Add(wrappedType);
|
||||
}
|
||||
else if (type.Resolve().FullName == "System.Collections.Generic.List`1")
|
||||
{
|
||||
var wrappedType = ((GenericInstanceType)type).GenericArguments[0];
|
||||
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_List_MethodRef);
|
||||
|
||||
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_List_MethodRef);
|
||||
serializeMethod.GenericArguments.Add(wrappedType);
|
||||
equalityMethod.GenericArguments.Add(wrappedType);
|
||||
}
|
||||
else if (type.Resolve().FullName == "System.Collections.Generic.HashSet`1")
|
||||
{
|
||||
var wrappedType = ((GenericInstanceType)type).GenericArguments[0];
|
||||
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_HashSet_MethodRef);
|
||||
|
||||
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_HashSet_MethodRef);
|
||||
serializeMethod.GenericArguments.Add(wrappedType);
|
||||
equalityMethod.GenericArguments.Add(wrappedType);
|
||||
}
|
||||
else if (type.Resolve().FullName == "System.Collections.Generic.Dictionary`2")
|
||||
{
|
||||
var wrappedKeyType = ((GenericInstanceType)type).GenericArguments[0];
|
||||
var wrappedValType = ((GenericInstanceType)type).GenericArguments[1];
|
||||
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_Dictionary_MethodRef);
|
||||
|
||||
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_Dictionary_MethodRef);
|
||||
serializeMethod.GenericArguments.Add(wrappedKeyType);
|
||||
serializeMethod.GenericArguments.Add(wrappedValType);
|
||||
equalityMethod.GenericArguments.Add(wrappedKeyType);
|
||||
equalityMethod.GenericArguments.Add(wrappedValType);
|
||||
}
|
||||
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
|
||||
else if (type.Resolve().FullName == "Unity.Collections.NativeList`1")
|
||||
{
|
||||
@@ -267,12 +328,30 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsList_MethodRef);
|
||||
}
|
||||
|
||||
if (serializeMethod != null)
|
||||
{
|
||||
serializeMethod.GenericArguments.Add(wrappedType);
|
||||
}
|
||||
serializeMethod?.GenericArguments.Add(wrappedType);
|
||||
equalityMethod.GenericArguments.Add(wrappedType);
|
||||
}
|
||||
else if (type.Resolve().FullName == "Unity.Collections.NativeHashSet`1")
|
||||
{
|
||||
var wrappedType = ((GenericInstanceType)type).GenericArguments[0];
|
||||
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_NativeHashSet_MethodRef);
|
||||
|
||||
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_NativeHashSet_MethodRef);
|
||||
serializeMethod.GenericArguments.Add(wrappedType);
|
||||
equalityMethod.GenericArguments.Add(wrappedType);
|
||||
}
|
||||
else if (type.Resolve().FullName == "Unity.Collections.NativeHashMap`2")
|
||||
{
|
||||
var wrappedKeyType = ((GenericInstanceType)type).GenericArguments[0];
|
||||
var wrappedValType = ((GenericInstanceType)type).GenericArguments[1];
|
||||
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_NativeHashMap_MethodRef);
|
||||
|
||||
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_NativeHashMap_MethodRef);
|
||||
serializeMethod.GenericArguments.Add(wrappedKeyType);
|
||||
serializeMethod.GenericArguments.Add(wrappedValType);
|
||||
equalityMethod.GenericArguments.Add(wrappedKeyType);
|
||||
equalityMethod.GenericArguments.Add(wrappedValType);
|
||||
}
|
||||
#endif
|
||||
else if (type.IsValueType)
|
||||
{
|
||||
@@ -329,6 +408,7 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
}
|
||||
else
|
||||
{
|
||||
m_Diagnostics.AddError($"{type}: Managed type in NetworkVariable must implement IEquatable<{type}>");
|
||||
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedClassEquals_MethodRef);
|
||||
}
|
||||
|
||||
@@ -363,11 +443,14 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
private FieldReference m_NetworkManager_LogLevel_FieldRef;
|
||||
private MethodReference m_NetworkBehaviour___registerRpc_MethodRef;
|
||||
private TypeReference m_NetworkBehaviour_TypeRef;
|
||||
private TypeReference m_AttributeParamsType_TypeRef;
|
||||
private TypeReference m_NetworkVariableBase_TypeRef;
|
||||
private MethodReference m_NetworkVariableBase_Initialize_MethodRef;
|
||||
private MethodReference m_NetworkBehaviour___nameNetworkVariable_MethodRef;
|
||||
private MethodReference m_NetworkBehaviour_beginSendServerRpc_MethodRef;
|
||||
private MethodReference m_NetworkBehaviour_endSendServerRpc_MethodRef;
|
||||
private MethodReference m_NetworkBehaviour_beginSendRpc_MethodRef;
|
||||
private MethodReference m_NetworkBehaviour_endSendRpc_MethodRef;
|
||||
private MethodReference m_NetworkBehaviour_beginSendClientRpc_MethodRef;
|
||||
private MethodReference m_NetworkBehaviour_endSendClientRpc_MethodRef;
|
||||
private FieldReference m_NetworkBehaviour_rpc_exec_stage_FieldRef;
|
||||
@@ -378,9 +461,13 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
private TypeReference m_RpcParams_TypeRef;
|
||||
private FieldReference m_RpcParams_Server_FieldRef;
|
||||
private FieldReference m_RpcParams_Client_FieldRef;
|
||||
private FieldReference m_RpcParams_Ext_FieldRef;
|
||||
private TypeReference m_ServerRpcParams_TypeRef;
|
||||
private FieldReference m_ServerRpcParams_Receive_FieldRef;
|
||||
private FieldReference m_ServerRpcParams_Receive_SenderClientId_FieldRef;
|
||||
private FieldReference m_UniversalRpcParams_Receive_FieldRef;
|
||||
private FieldReference m_UniversalRpcParams_Receive_SenderClientId_FieldRef;
|
||||
private TypeReference m_UniversalRpcParams_TypeRef;
|
||||
private TypeReference m_ClientRpcParams_TypeRef;
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpy_MethodRef;
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpyArray_MethodRef;
|
||||
@@ -391,7 +478,12 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableArray_MethodRef;
|
||||
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableList_MethodRef;
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_NativeHashSet_MethodRef;
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_NativeHashMap_MethodRef;
|
||||
#endif
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_List_MethodRef;
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_HashSet_MethodRef;
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_Dictionary_MethodRef;
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_ManagedINetworkSerializable_MethodRef;
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_FixedString_MethodRef;
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_FixedStringArray_MethodRef;
|
||||
@@ -408,7 +500,12 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsArray_MethodRef;
|
||||
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsList_MethodRef;
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_NativeHashSet_MethodRef;
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_NativeHashMap_MethodRef;
|
||||
#endif
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_List_MethodRef;
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_HashSet_MethodRef;
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_Dictionary_MethodRef;
|
||||
private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedClassEquals_MethodRef;
|
||||
|
||||
private MethodReference m_RuntimeInitializeOnLoadAttribute_Ctor;
|
||||
@@ -495,6 +592,8 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
private const string k_NetworkBehaviour_NetworkVariableFields = nameof(NetworkBehaviour.NetworkVariableFields);
|
||||
private const string k_NetworkBehaviour_beginSendServerRpc = nameof(NetworkBehaviour.__beginSendServerRpc);
|
||||
private const string k_NetworkBehaviour_endSendServerRpc = nameof(NetworkBehaviour.__endSendServerRpc);
|
||||
private const string k_NetworkBehaviour_beginSendRpc = nameof(NetworkBehaviour.__beginSendRpc);
|
||||
private const string k_NetworkBehaviour_endSendRpc = nameof(NetworkBehaviour.__endSendRpc);
|
||||
private const string k_NetworkBehaviour_beginSendClientRpc = nameof(NetworkBehaviour.__beginSendClientRpc);
|
||||
private const string k_NetworkBehaviour_endSendClientRpc = nameof(NetworkBehaviour.__endSendClientRpc);
|
||||
private const string k_NetworkBehaviour___initializeVariables = nameof(NetworkBehaviour.__initializeVariables);
|
||||
@@ -511,8 +610,11 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
private const string k_ServerRpcAttribute_RequireOwnership = nameof(ServerRpcAttribute.RequireOwnership);
|
||||
private const string k_RpcParams_Server = nameof(__RpcParams.Server);
|
||||
private const string k_RpcParams_Client = nameof(__RpcParams.Client);
|
||||
private const string k_RpcParams_Ext = nameof(__RpcParams.Ext);
|
||||
private const string k_ServerRpcParams_Receive = nameof(ServerRpcParams.Receive);
|
||||
private const string k_RpcParams_Receive = nameof(RpcParams.Receive);
|
||||
private const string k_ServerRpcReceiveParams_SenderClientId = nameof(ServerRpcReceiveParams.SenderClientId);
|
||||
private const string k_RpcReceiveParams_SenderClientId = nameof(RpcReceiveParams.SenderClientId);
|
||||
|
||||
// CodeGen cannot reference the collections assembly to do a typeof() on it due to a bug that causes that to crash.
|
||||
private const string k_INativeListBool_FullName = "Unity.Collections.INativeList`1<System.Byte>";
|
||||
@@ -545,13 +647,20 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
TypeDefinition rpcParamsTypeDef = null;
|
||||
TypeDefinition serverRpcParamsTypeDef = null;
|
||||
TypeDefinition clientRpcParamsTypeDef = null;
|
||||
TypeDefinition universalRpcParamsTypeDef = null;
|
||||
TypeDefinition fastBufferWriterTypeDef = null;
|
||||
TypeDefinition fastBufferReaderTypeDef = null;
|
||||
TypeDefinition networkVariableSerializationTypesTypeDef = null;
|
||||
TypeDefinition bytePackerTypeDef = null;
|
||||
TypeDefinition byteUnpackerTypeDef = null;
|
||||
TypeDefinition attributeParamsType = null;
|
||||
foreach (var netcodeTypeDef in m_NetcodeModule.GetAllTypes())
|
||||
{
|
||||
if (attributeParamsType == null && netcodeTypeDef.Name == nameof(RpcAttribute.RpcAttributeParams))
|
||||
{
|
||||
attributeParamsType = netcodeTypeDef;
|
||||
continue;
|
||||
}
|
||||
if (networkManagerTypeDef == null && netcodeTypeDef.Name == nameof(NetworkManager))
|
||||
{
|
||||
networkManagerTypeDef = netcodeTypeDef;
|
||||
@@ -588,6 +697,12 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
continue;
|
||||
}
|
||||
|
||||
if (universalRpcParamsTypeDef == null && netcodeTypeDef.Name == nameof(RpcParams))
|
||||
{
|
||||
universalRpcParamsTypeDef = netcodeTypeDef;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (clientRpcParamsTypeDef == null && netcodeTypeDef.Name == nameof(ClientRpcParams))
|
||||
{
|
||||
clientRpcParamsTypeDef = netcodeTypeDef;
|
||||
@@ -662,6 +777,8 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
}
|
||||
}
|
||||
|
||||
m_AttributeParamsType_TypeRef = moduleDefinition.ImportReference(attributeParamsType);
|
||||
|
||||
foreach (var fieldDef in networkManagerTypeDef.Fields)
|
||||
{
|
||||
switch (fieldDef.Name)
|
||||
@@ -696,6 +813,12 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
case k_NetworkBehaviour_endSendServerRpc:
|
||||
m_NetworkBehaviour_endSendServerRpc_MethodRef = moduleDefinition.ImportReference(methodDef);
|
||||
break;
|
||||
case k_NetworkBehaviour_beginSendRpc:
|
||||
m_NetworkBehaviour_beginSendRpc_MethodRef = moduleDefinition.ImportReference(methodDef);
|
||||
break;
|
||||
case k_NetworkBehaviour_endSendRpc:
|
||||
m_NetworkBehaviour_endSendRpc_MethodRef = moduleDefinition.ImportReference(methodDef);
|
||||
break;
|
||||
case k_NetworkBehaviour_beginSendClientRpc:
|
||||
m_NetworkBehaviour_beginSendClientRpc_MethodRef = moduleDefinition.ImportReference(methodDef);
|
||||
break;
|
||||
@@ -763,6 +886,9 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
case k_RpcParams_Client:
|
||||
m_RpcParams_Client_FieldRef = moduleDefinition.ImportReference(fieldDef);
|
||||
break;
|
||||
case k_RpcParams_Ext:
|
||||
m_RpcParams_Ext_FieldRef = moduleDefinition.ImportReference(fieldDef);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -786,6 +912,26 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
break;
|
||||
}
|
||||
}
|
||||
m_UniversalRpcParams_TypeRef = moduleDefinition.ImportReference(universalRpcParamsTypeDef);
|
||||
foreach (var fieldDef in rpcParamsTypeDef.Fields)
|
||||
{
|
||||
switch (fieldDef.Name)
|
||||
{
|
||||
case k_RpcParams_Receive:
|
||||
foreach (var recvFieldDef in fieldDef.FieldType.Resolve().Fields)
|
||||
{
|
||||
switch (recvFieldDef.Name)
|
||||
{
|
||||
case k_RpcReceiveParams_SenderClientId:
|
||||
m_UniversalRpcParams_Receive_SenderClientId_FieldRef = moduleDefinition.ImportReference(recvFieldDef);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
m_UniversalRpcParams_Receive_FieldRef = moduleDefinition.ImportReference(fieldDef);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
m_ClientRpcParams_TypeRef = moduleDefinition.ImportReference(clientRpcParamsTypeDef);
|
||||
m_FastBufferWriter_TypeRef = moduleDefinition.ImportReference(fastBufferWriterTypeDef);
|
||||
@@ -884,7 +1030,22 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializableList):
|
||||
m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableList_MethodRef = method;
|
||||
break;
|
||||
case nameof(NetworkVariableSerializationTypes.InitializeSerializer_NativeHashSet):
|
||||
m_NetworkVariableSerializationTypes_InitializeSerializer_NativeHashSet_MethodRef = method;
|
||||
break;
|
||||
case nameof(NetworkVariableSerializationTypes.InitializeSerializer_NativeHashMap):
|
||||
m_NetworkVariableSerializationTypes_InitializeSerializer_NativeHashMap_MethodRef = method;
|
||||
break;
|
||||
#endif
|
||||
case nameof(NetworkVariableSerializationTypes.InitializeSerializer_List):
|
||||
m_NetworkVariableSerializationTypes_InitializeSerializer_List_MethodRef = method;
|
||||
break;
|
||||
case nameof(NetworkVariableSerializationTypes.InitializeSerializer_HashSet):
|
||||
m_NetworkVariableSerializationTypes_InitializeSerializer_HashSet_MethodRef = method;
|
||||
break;
|
||||
case nameof(NetworkVariableSerializationTypes.InitializeSerializer_Dictionary):
|
||||
m_NetworkVariableSerializationTypes_InitializeSerializer_Dictionary_MethodRef = method;
|
||||
break;
|
||||
case nameof(NetworkVariableSerializationTypes.InitializeSerializer_ManagedINetworkSerializable):
|
||||
m_NetworkVariableSerializationTypes_InitializeSerializer_ManagedINetworkSerializable_MethodRef = method;
|
||||
break;
|
||||
@@ -915,7 +1076,22 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatableList):
|
||||
m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatableList_MethodRef = method;
|
||||
break;
|
||||
case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_NativeHashSet):
|
||||
m_NetworkVariableSerializationTypes_InitializeEqualityChecker_NativeHashSet_MethodRef = method;
|
||||
break;
|
||||
case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_NativeHashMap):
|
||||
m_NetworkVariableSerializationTypes_InitializeEqualityChecker_NativeHashMap_MethodRef = method;
|
||||
break;
|
||||
#endif
|
||||
case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_List):
|
||||
m_NetworkVariableSerializationTypes_InitializeEqualityChecker_List_MethodRef = method;
|
||||
break;
|
||||
case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_HashSet):
|
||||
m_NetworkVariableSerializationTypes_InitializeEqualityChecker_HashSet_MethodRef = method;
|
||||
break;
|
||||
case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_Dictionary):
|
||||
m_NetworkVariableSerializationTypes_InitializeEqualityChecker_Dictionary_MethodRef = method;
|
||||
break;
|
||||
case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEquals):
|
||||
m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEquals_MethodRef = method;
|
||||
break;
|
||||
@@ -1190,10 +1366,7 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
continue;
|
||||
}
|
||||
var wrappedType = genericInstanceType.GenericArguments[idx];
|
||||
if (!m_WrappedNetworkVariableTypes.Contains(wrappedType))
|
||||
{
|
||||
m_WrappedNetworkVariableTypes.Add(wrappedType);
|
||||
}
|
||||
AddWrappedType(wrappedType);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1226,10 +1399,7 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
continue;
|
||||
}
|
||||
var wrappedType = genericInstanceType.GenericArguments[idx];
|
||||
if (!m_WrappedNetworkVariableTypes.Contains(wrappedType))
|
||||
{
|
||||
m_WrappedNetworkVariableTypes.Add(wrappedType);
|
||||
}
|
||||
AddWrappedType(wrappedType);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1354,7 +1524,8 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
var customAttributeType_FullName = customAttribute.AttributeType.FullName;
|
||||
|
||||
if (customAttributeType_FullName == CodeGenHelpers.ServerRpcAttribute_FullName ||
|
||||
customAttributeType_FullName == CodeGenHelpers.ClientRpcAttribute_FullName)
|
||||
customAttributeType_FullName == CodeGenHelpers.ClientRpcAttribute_FullName ||
|
||||
customAttributeType_FullName == CodeGenHelpers.RpcAttribute_FullName)
|
||||
{
|
||||
bool isValid = true;
|
||||
|
||||
@@ -1389,6 +1560,13 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
isValid = false;
|
||||
}
|
||||
|
||||
if (customAttributeType_FullName == CodeGenHelpers.RpcAttribute_FullName &&
|
||||
!methodDefinition.Name.EndsWith("Rpc", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
m_Diagnostics.AddError(methodDefinition, "Rpc method must end with 'Rpc' suffix!");
|
||||
isValid = false;
|
||||
}
|
||||
|
||||
if (customAttributeType_FullName == CodeGenHelpers.ClientRpcAttribute_FullName &&
|
||||
!methodDefinition.Name.EndsWith("ClientRpc", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
@@ -1411,11 +1589,15 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
{
|
||||
if (methodDefinition.Name.EndsWith("ServerRpc", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
m_Diagnostics.AddError(methodDefinition, "ServerRpc method must be marked with 'ServerRpc' attribute!");
|
||||
m_Diagnostics.AddError(methodDefinition, $"ServerRpc method {methodDefinition} must be marked with 'ServerRpc' attribute!");
|
||||
}
|
||||
else if (methodDefinition.Name.EndsWith("ClientRpc", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
m_Diagnostics.AddError(methodDefinition, "ClientRpc method must be marked with 'ClientRpc' attribute!");
|
||||
m_Diagnostics.AddError(methodDefinition, $"ClientRpc method {methodDefinition} must be marked with 'ClientRpc' attribute!");
|
||||
}
|
||||
else if (methodDefinition.Name.EndsWith("ExtRpc", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
m_Diagnostics.AddError(methodDefinition, $"Ext Rpc method {methodDefinition} must be marked with 'ExtRpc' attribute!");
|
||||
}
|
||||
|
||||
return null;
|
||||
@@ -1887,8 +2069,17 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
var instructions = new List<Instruction>();
|
||||
var processor = methodDefinition.Body.GetILProcessor();
|
||||
var isServerRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.ServerRpcAttribute_FullName;
|
||||
var isClientRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.ClientRpcAttribute_FullName;
|
||||
var isGenericRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.RpcAttribute_FullName;
|
||||
var requireOwnership = true; // default value MUST be == `ServerRpcAttribute.RequireOwnership`
|
||||
var rpcDelivery = RpcDelivery.Reliable; // default value MUST be == `RpcAttribute.Delivery`
|
||||
var defaultTarget = SendTo.Everyone;
|
||||
var allowTargetOverride = false;
|
||||
|
||||
if (isGenericRpc)
|
||||
{
|
||||
defaultTarget = (SendTo)rpcAttribute.ConstructorArguments[0].Value;
|
||||
}
|
||||
foreach (var attrField in rpcAttribute.Fields)
|
||||
{
|
||||
switch (attrField.Name)
|
||||
@@ -1899,6 +2090,9 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
case k_ServerRpcAttribute_RequireOwnership:
|
||||
requireOwnership = attrField.Argument.Type == typeSystem.Boolean && (bool)attrField.Argument.Value;
|
||||
break;
|
||||
case nameof(RpcAttribute.AllowTargetOverride):
|
||||
allowTargetOverride = attrField.Argument.Type == typeSystem.Boolean && (bool)attrField.Argument.Value;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1906,7 +2100,33 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
var hasRpcParams =
|
||||
paramCount > 0 &&
|
||||
((isServerRpc && methodDefinition.Parameters[paramCount - 1].ParameterType.FullName == CodeGenHelpers.ServerRpcParams_FullName) ||
|
||||
(!isServerRpc && methodDefinition.Parameters[paramCount - 1].ParameterType.FullName == CodeGenHelpers.ClientRpcParams_FullName));
|
||||
(isClientRpc && methodDefinition.Parameters[paramCount - 1].ParameterType.FullName == CodeGenHelpers.ClientRpcParams_FullName) ||
|
||||
(isGenericRpc && methodDefinition.Parameters[paramCount - 1].ParameterType.FullName == CodeGenHelpers.RpcParams_FullName));
|
||||
|
||||
if (isGenericRpc && defaultTarget == SendTo.SpecifiedInParams)
|
||||
{
|
||||
if (!hasRpcParams)
|
||||
{
|
||||
m_Diagnostics.AddError($"{methodDefinition}: {nameof(SendTo)}.{nameof(SendTo.SpecifiedInParams)} cannot be used without a final parameter of type {CodeGenHelpers.RpcParams_FullName}.");
|
||||
}
|
||||
|
||||
foreach (var attrField in rpcAttribute.Fields)
|
||||
{
|
||||
switch (attrField.Name)
|
||||
{
|
||||
case nameof(RpcAttribute.AllowTargetOverride):
|
||||
m_Diagnostics.AddWarning($"{methodDefinition}: {nameof(RpcAttribute.AllowTargetOverride)} is ignored with {nameof(SendTo)}.{nameof(SendTo.SpecifiedInParams)}");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (isGenericRpc && allowTargetOverride)
|
||||
{
|
||||
if (!hasRpcParams)
|
||||
{
|
||||
m_Diagnostics.AddError($"{methodDefinition}: {nameof(RpcAttribute.AllowTargetOverride)} cannot be used without a final parameter of type {CodeGenHelpers.RpcParams_FullName}.");
|
||||
}
|
||||
}
|
||||
|
||||
methodDefinition.Body.InitLocals = true;
|
||||
// NetworkManager networkManager;
|
||||
@@ -1919,10 +2139,17 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
// XXXRpcParams
|
||||
if (!hasRpcParams)
|
||||
{
|
||||
methodDefinition.Body.Variables.Add(new VariableDefinition(isServerRpc ? m_ServerRpcParams_TypeRef : m_ClientRpcParams_TypeRef));
|
||||
methodDefinition.Body.Variables.Add(new VariableDefinition(isServerRpc ? m_ServerRpcParams_TypeRef : (isClientRpc ? m_ClientRpcParams_TypeRef : m_UniversalRpcParams_TypeRef)));
|
||||
}
|
||||
int rpcParamsIdx = !hasRpcParams ? methodDefinition.Body.Variables.Count - 1 : -1;
|
||||
|
||||
if (isGenericRpc)
|
||||
{
|
||||
methodDefinition.Body.Variables.Add(new VariableDefinition(m_AttributeParamsType_TypeRef));
|
||||
}
|
||||
|
||||
int rpcAttributeParamsIdx = isGenericRpc ? methodDefinition.Body.Variables.Count - 1 : -1;
|
||||
|
||||
{
|
||||
var returnInstr = processor.Create(OpCodes.Ret);
|
||||
var lastInstr = processor.Create(OpCodes.Nop);
|
||||
@@ -1952,20 +2179,23 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
// if (__rpc_exec_stage != __RpcExecStage.Client) -> ClientRpc
|
||||
instructions.Add(processor.Create(OpCodes.Ldarg_0));
|
||||
instructions.Add(processor.Create(OpCodes.Ldfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef));
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)(isServerRpc ? NetworkBehaviour.__RpcExecStage.Server : NetworkBehaviour.__RpcExecStage.Client)));
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.Execute));
|
||||
instructions.Add(processor.Create(OpCodes.Ceq));
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_I4, 0));
|
||||
instructions.Add(processor.Create(OpCodes.Ceq));
|
||||
instructions.Add(processor.Create(OpCodes.Brfalse, lastInstr));
|
||||
|
||||
// if (networkManager.IsClient || networkManager.IsHost) { ... } -> ServerRpc
|
||||
// if (networkManager.IsServer || networkManager.IsHost) { ... } -> ClientRpc
|
||||
instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
|
||||
instructions.Add(processor.Create(OpCodes.Callvirt, isServerRpc ? m_NetworkManager_getIsClient_MethodRef : m_NetworkManager_getIsServer_MethodRef));
|
||||
instructions.Add(processor.Create(OpCodes.Brtrue, beginInstr));
|
||||
instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
|
||||
instructions.Add(processor.Create(OpCodes.Callvirt, m_NetworkManager_getIsHost_MethodRef));
|
||||
instructions.Add(processor.Create(OpCodes.Brfalse, lastInstr));
|
||||
if (!isGenericRpc)
|
||||
{
|
||||
// if (networkManager.IsClient || networkManager.IsHost) { ... } -> ServerRpc
|
||||
// if (networkManager.IsServer || networkManager.IsHost) { ... } -> ClientRpc
|
||||
instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
|
||||
instructions.Add(processor.Create(OpCodes.Callvirt, isServerRpc ? m_NetworkManager_getIsClient_MethodRef : m_NetworkManager_getIsServer_MethodRef));
|
||||
instructions.Add(processor.Create(OpCodes.Brtrue, beginInstr));
|
||||
instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
|
||||
instructions.Add(processor.Create(OpCodes.Callvirt, m_NetworkManager_getIsHost_MethodRef));
|
||||
instructions.Add(processor.Create(OpCodes.Brfalse, lastInstr));
|
||||
}
|
||||
|
||||
instructions.Add(beginInstr);
|
||||
|
||||
@@ -2027,7 +2257,7 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_beginSendServerRpc_MethodRef));
|
||||
instructions.Add(processor.Create(OpCodes.Stloc, bufWriterLocIdx));
|
||||
}
|
||||
else
|
||||
else if (isClientRpc)
|
||||
{
|
||||
// ClientRpc
|
||||
|
||||
@@ -2047,6 +2277,89 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_beginSendClientRpc_MethodRef));
|
||||
instructions.Add(processor.Create(OpCodes.Stloc, bufWriterLocIdx));
|
||||
}
|
||||
else
|
||||
{
|
||||
// Generic RPC
|
||||
|
||||
// var bufferWriter = __beginSendRpc(rpcMethodId, rpcParams, rpcAttributeParams, defaultTarget, rpcDelivery);
|
||||
instructions.Add(processor.Create(OpCodes.Ldarg_0));
|
||||
|
||||
// rpcMethodId
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_I4, unchecked((int)rpcMethodId)));
|
||||
|
||||
// rpcParams
|
||||
instructions.Add(hasRpcParams ? processor.Create(OpCodes.Ldarg, paramCount) : processor.Create(OpCodes.Ldloc, rpcParamsIdx));
|
||||
|
||||
// rpcAttributeParams
|
||||
instructions.Add(processor.Create(OpCodes.Ldloca, rpcAttributeParamsIdx));
|
||||
instructions.Add(processor.Create(OpCodes.Initobj, m_AttributeParamsType_TypeRef));
|
||||
|
||||
RpcAttribute.RpcAttributeParams dflt = default;
|
||||
foreach (var field in rpcAttribute.Fields)
|
||||
{
|
||||
var found = false;
|
||||
foreach (var attrField in m_AttributeParamsType_TypeRef.Resolve().Fields)
|
||||
{
|
||||
if (attrField.Name == field.Name)
|
||||
{
|
||||
found = true;
|
||||
var value = field.Argument.Value;
|
||||
var paramField = dflt.GetType().GetField(attrField.Name);
|
||||
if (value != paramField.GetValue(dflt))
|
||||
{
|
||||
instructions.Add(processor.Create(OpCodes.Ldloca, rpcAttributeParamsIdx));
|
||||
var type = value.GetType();
|
||||
if (type == typeof(bool))
|
||||
{
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_I4, (bool)value ? 1 : 0));
|
||||
}
|
||||
else if (type == typeof(short) || type == typeof(int) || type == typeof(ushort)
|
||||
|| type == typeof(byte) || type == typeof(sbyte) || type == typeof(char))
|
||||
{
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)value));
|
||||
}
|
||||
else if (type == typeof(long) || type == typeof(ulong))
|
||||
{
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_I8, (long)value));
|
||||
}
|
||||
else if (type == typeof(float))
|
||||
{
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_R8, (float)value));
|
||||
|
||||
}
|
||||
else if (type == typeof(double))
|
||||
{
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_R8, (double)value));
|
||||
}
|
||||
else
|
||||
{
|
||||
m_Diagnostics.AddError("Unsupported attribute parameter type.");
|
||||
}
|
||||
}
|
||||
|
||||
instructions.Add(processor.Create(OpCodes.Stfld, m_MainModule.ImportReference(attrField)));
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found)
|
||||
{
|
||||
m_Diagnostics.AddError($"{nameof(RpcAttribute)} contains field {field} which is not present in {nameof(RpcAttribute.RpcAttributeParams)}.");
|
||||
}
|
||||
}
|
||||
instructions.Add(processor.Create(OpCodes.Ldloc, rpcAttributeParamsIdx));
|
||||
|
||||
// defaultTarget
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)defaultTarget));
|
||||
|
||||
// rpcDelivery
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)rpcDelivery));
|
||||
|
||||
// __beginSendRpc
|
||||
instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_beginSendRpc_MethodRef));
|
||||
instructions.Add(processor.Create(OpCodes.Stloc, bufWriterLocIdx));
|
||||
}
|
||||
|
||||
// write method parameters into stream
|
||||
for (int paramIndex = 0; paramIndex < paramCount; ++paramIndex)
|
||||
@@ -2075,7 +2388,7 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
}
|
||||
if (!isServerRpc)
|
||||
{
|
||||
m_Diagnostics.AddError($"ClientRpcs may not accept {nameof(ServerRpcParams)} as a parameter.");
|
||||
m_Diagnostics.AddError($"Only ServerRpcs may accept {nameof(ServerRpcParams)} as a parameter.");
|
||||
}
|
||||
continue;
|
||||
}
|
||||
@@ -2086,9 +2399,22 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
{
|
||||
m_Diagnostics.AddError(methodDefinition, $"{nameof(ClientRpcParams)} must be the last parameter in a ClientRpc.");
|
||||
}
|
||||
if (isServerRpc)
|
||||
if (!isClientRpc)
|
||||
{
|
||||
m_Diagnostics.AddError($"ServerRpcs may not accept {nameof(ClientRpcParams)} as a parameter.");
|
||||
m_Diagnostics.AddError($"Only clientRpcs may accept {nameof(ClientRpcParams)} as a parameter.");
|
||||
}
|
||||
continue;
|
||||
}
|
||||
// RpcParams
|
||||
if (paramType.FullName == CodeGenHelpers.RpcParams_FullName)
|
||||
{
|
||||
if (paramIndex != paramCount - 1)
|
||||
{
|
||||
m_Diagnostics.AddError(methodDefinition, $"{nameof(RpcParams)} must be the last parameter in a ClientRpc.");
|
||||
}
|
||||
if (!isGenericRpc)
|
||||
{
|
||||
m_Diagnostics.AddError($"Only Rpcs may accept {nameof(RpcParams)} as a parameter.");
|
||||
}
|
||||
continue;
|
||||
}
|
||||
@@ -2251,7 +2577,7 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
// __endSendServerRpc
|
||||
instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_endSendServerRpc_MethodRef));
|
||||
}
|
||||
else
|
||||
else if (isClientRpc)
|
||||
{
|
||||
// ClientRpc
|
||||
|
||||
@@ -2279,6 +2605,41 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
// __endSendClientRpc
|
||||
instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_endSendClientRpc_MethodRef));
|
||||
}
|
||||
else
|
||||
{
|
||||
// Generic Rpc
|
||||
|
||||
// __endSendRpc(ref bufferWriter, rpcMethodId, rpcParams, rpcAttributeParams, defaultTarget, rpcDelivery);
|
||||
instructions.Add(processor.Create(OpCodes.Ldarg_0));
|
||||
|
||||
// bufferWriter
|
||||
instructions.Add(processor.Create(OpCodes.Ldloca, bufWriterLocIdx));
|
||||
|
||||
// rpcMethodId
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_I4, unchecked((int)rpcMethodId)));
|
||||
if (hasRpcParams)
|
||||
{
|
||||
// rpcParams
|
||||
instructions.Add(processor.Create(OpCodes.Ldarg, paramCount));
|
||||
}
|
||||
else
|
||||
{
|
||||
// default
|
||||
instructions.Add(processor.Create(OpCodes.Ldloc, rpcParamsIdx));
|
||||
}
|
||||
|
||||
// rpcAttributeParams
|
||||
instructions.Add(processor.Create(OpCodes.Ldloc, rpcAttributeParamsIdx));
|
||||
|
||||
// defaultTarget
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)defaultTarget));
|
||||
|
||||
// rpcDelivery
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)rpcDelivery));
|
||||
|
||||
// __endSendClientRpc
|
||||
instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_endSendRpc_MethodRef));
|
||||
}
|
||||
|
||||
instructions.Add(lastInstr);
|
||||
}
|
||||
@@ -2287,25 +2648,53 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
var returnInstr = processor.Create(OpCodes.Ret);
|
||||
var lastInstr = processor.Create(OpCodes.Nop);
|
||||
|
||||
// if (__rpc_exec_stage == __RpcExecStage.Server) -> ServerRpc
|
||||
// if (__rpc_exec_stage == __RpcExecStage.Client) -> ClientRpc
|
||||
instructions.Add(processor.Create(OpCodes.Ldarg_0));
|
||||
instructions.Add(processor.Create(OpCodes.Ldfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef));
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)(isServerRpc ? NetworkBehaviour.__RpcExecStage.Server : NetworkBehaviour.__RpcExecStage.Client)));
|
||||
instructions.Add(processor.Create(OpCodes.Ceq));
|
||||
instructions.Add(processor.Create(OpCodes.Brfalse, returnInstr));
|
||||
if (!isGenericRpc)
|
||||
{
|
||||
// if (__rpc_exec_stage == __RpcExecStage.Execute)
|
||||
instructions.Add(processor.Create(OpCodes.Ldarg_0));
|
||||
instructions.Add(processor.Create(OpCodes.Ldfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef));
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.Execute));
|
||||
instructions.Add(processor.Create(OpCodes.Ceq));
|
||||
instructions.Add(processor.Create(OpCodes.Brfalse, returnInstr));
|
||||
|
||||
// if (networkManager.IsServer || networkManager.IsHost) -> ServerRpc
|
||||
// if (networkManager.IsClient || networkManager.IsHost) -> ClientRpc
|
||||
instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
|
||||
instructions.Add(processor.Create(OpCodes.Callvirt, isServerRpc ? m_NetworkManager_getIsServer_MethodRef : m_NetworkManager_getIsClient_MethodRef));
|
||||
instructions.Add(processor.Create(OpCodes.Brtrue, lastInstr));
|
||||
instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
|
||||
instructions.Add(processor.Create(OpCodes.Callvirt, m_NetworkManager_getIsHost_MethodRef));
|
||||
instructions.Add(processor.Create(OpCodes.Brtrue, lastInstr));
|
||||
// if (networkManager.IsServer || networkManager.IsHost) -> ServerRpc
|
||||
// if (networkManager.IsClient || networkManager.IsHost) -> ClientRpc
|
||||
instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
|
||||
instructions.Add(processor.Create(OpCodes.Callvirt, isServerRpc ? m_NetworkManager_getIsServer_MethodRef : m_NetworkManager_getIsClient_MethodRef));
|
||||
instructions.Add(processor.Create(OpCodes.Brtrue, lastInstr));
|
||||
instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
|
||||
instructions.Add(processor.Create(OpCodes.Callvirt, m_NetworkManager_getIsHost_MethodRef));
|
||||
instructions.Add(processor.Create(OpCodes.Brtrue, lastInstr));
|
||||
instructions.Add(returnInstr);
|
||||
instructions.Add(lastInstr);
|
||||
|
||||
// This needs to be set back before executing the callback or else sending another RPC
|
||||
// from within an RPC will not work.
|
||||
// __rpc_exec_stage = __RpcExecStage.Send
|
||||
instructions.Add(processor.Create(OpCodes.Ldarg_0));
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.Send));
|
||||
instructions.Add(processor.Create(OpCodes.Stfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef));
|
||||
}
|
||||
else
|
||||
{
|
||||
// if (__rpc_exec_stage == __RpcExecStage.Execute)
|
||||
instructions.Add(processor.Create(OpCodes.Ldarg_0));
|
||||
instructions.Add(processor.Create(OpCodes.Ldfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef));
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.Execute));
|
||||
instructions.Add(processor.Create(OpCodes.Ceq));
|
||||
instructions.Add(processor.Create(OpCodes.Brtrue, lastInstr));
|
||||
|
||||
instructions.Add(returnInstr);
|
||||
instructions.Add(lastInstr);
|
||||
|
||||
// This needs to be set back before executing the callback or else sending another RPC
|
||||
// from within an RPC will not work.
|
||||
// __rpc_exec_stage = __RpcExecStage.Send
|
||||
instructions.Add(processor.Create(OpCodes.Ldarg_0));
|
||||
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.Send));
|
||||
instructions.Add(processor.Create(OpCodes.Stfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef));
|
||||
}
|
||||
|
||||
instructions.Add(returnInstr);
|
||||
instructions.Add(lastInstr);
|
||||
}
|
||||
|
||||
instructions.Reverse();
|
||||
@@ -2458,6 +2847,8 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
var processor = rpcHandler.Body.GetILProcessor();
|
||||
|
||||
var isServerRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.ServerRpcAttribute_FullName;
|
||||
var isCientRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.ClientRpcAttribute_FullName;
|
||||
var isGenericRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.RpcAttribute_FullName;
|
||||
var requireOwnership = true; // default value MUST be == `ServerRpcAttribute.RequireOwnership`
|
||||
foreach (var attrField in rpcAttribute.Fields)
|
||||
{
|
||||
@@ -2564,6 +2955,15 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
processor.Emit(OpCodes.Stloc, localIndex);
|
||||
continue;
|
||||
}
|
||||
|
||||
// RpcParams
|
||||
if (paramType.FullName == CodeGenHelpers.RpcParams_FullName)
|
||||
{
|
||||
processor.Emit(OpCodes.Ldarg_2);
|
||||
processor.Emit(OpCodes.Ldfld, m_RpcParams_Ext_FieldRef);
|
||||
processor.Emit(OpCodes.Stloc, localIndex);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
Instruction jumpInstruction = null;
|
||||
@@ -2690,7 +3090,7 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
// NetworkBehaviour.__rpc_exec_stage = __RpcExecStage.Server; -> ServerRpc
|
||||
// NetworkBehaviour.__rpc_exec_stage = __RpcExecStage.Client; -> ClientRpc
|
||||
processor.Emit(OpCodes.Ldarg_0);
|
||||
processor.Emit(OpCodes.Ldc_I4, (int)(isServerRpc ? NetworkBehaviour.__RpcExecStage.Server : NetworkBehaviour.__RpcExecStage.Client));
|
||||
processor.Emit(OpCodes.Ldc_I4, (int)(NetworkBehaviour.__RpcExecStage.Execute));
|
||||
processor.Emit(OpCodes.Stfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef);
|
||||
|
||||
// NetworkBehaviour.XXXRpc(...);
|
||||
@@ -2713,7 +3113,7 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
|
||||
// NetworkBehaviour.__rpc_exec_stage = __RpcExecStage.None;
|
||||
processor.Emit(OpCodes.Ldarg_0);
|
||||
processor.Emit(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.None);
|
||||
processor.Emit(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.Send);
|
||||
processor.Emit(OpCodes.Stfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef);
|
||||
|
||||
processor.Emit(OpCodes.Ret);
|
||||
|
||||
@@ -2,6 +2,7 @@ using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using Mono.Cecil;
|
||||
using Mono.Cecil.Cil;
|
||||
using Mono.Cecil.Rocks;
|
||||
using Unity.CompilationPipeline.Common.Diagnostics;
|
||||
using Unity.CompilationPipeline.Common.ILPostProcessing;
|
||||
using ILPPInterface = Unity.CompilationPipeline.Common.ILPostProcessing.ILPostProcessor;
|
||||
@@ -52,6 +53,15 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
case nameof(NetworkBehaviour):
|
||||
ProcessNetworkBehaviour(typeDefinition);
|
||||
break;
|
||||
case nameof(RpcAttribute):
|
||||
foreach (var methodDefinition in typeDefinition.GetConstructors())
|
||||
{
|
||||
if (methodDefinition.Parameters.Count == 0)
|
||||
{
|
||||
methodDefinition.IsPublic = true;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case nameof(__RpcParams):
|
||||
case nameof(RpcFallbackSerialization):
|
||||
typeDefinition.IsPublic = true;
|
||||
@@ -154,6 +164,8 @@ namespace Unity.Netcode.Editor.CodeGen
|
||||
methodDefinition.Name == nameof(NetworkBehaviour.__endSendServerRpc) ||
|
||||
methodDefinition.Name == nameof(NetworkBehaviour.__beginSendClientRpc) ||
|
||||
methodDefinition.Name == nameof(NetworkBehaviour.__endSendClientRpc) ||
|
||||
methodDefinition.Name == nameof(NetworkBehaviour.__beginSendRpc) ||
|
||||
methodDefinition.Name == nameof(NetworkBehaviour.__endSendRpc) ||
|
||||
methodDefinition.Name == nameof(NetworkBehaviour.__initializeVariables) ||
|
||||
methodDefinition.Name == nameof(NetworkBehaviour.__initializeRpcs) ||
|
||||
methodDefinition.Name == nameof(NetworkBehaviour.__registerRpc) ||
|
||||
|
||||
@@ -1,3 +1,6 @@
|
||||
#if UNITY_2022_3_OR_NEWER && (RELAY_SDK_INSTALLED && !UNITY_WEBGL ) || (RELAY_SDK_INSTALLED && UNITY_WEBGL && UTP_TRANSPORT_2_0_ABOVE)
|
||||
#define RELAY_INTEGRATION_AVAILABLE
|
||||
#endif
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
@@ -48,6 +51,27 @@ namespace Unity.Netcode.Editor
|
||||
private readonly List<Type> m_TransportTypes = new List<Type>();
|
||||
private string[] m_TransportNames = { "Select transport..." };
|
||||
|
||||
/// <inheritdoc/>
|
||||
public override void OnInspectorGUI()
|
||||
{
|
||||
Initialize();
|
||||
CheckNullProperties();
|
||||
|
||||
#if !MULTIPLAYER_TOOLS
|
||||
DrawInstallMultiplayerToolsTip();
|
||||
#endif
|
||||
|
||||
if (m_NetworkManager.IsServer || m_NetworkManager.IsClient)
|
||||
{
|
||||
DrawDisconnectButton();
|
||||
}
|
||||
else
|
||||
{
|
||||
DrawAllPropertyFields();
|
||||
ShowStartConnectionButtons();
|
||||
}
|
||||
}
|
||||
|
||||
private void ReloadTransports()
|
||||
{
|
||||
m_TransportTypes.Clear();
|
||||
@@ -138,209 +162,311 @@ namespace Unity.Netcode.Editor
|
||||
.FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists));
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public override void OnInspectorGUI()
|
||||
private void DrawAllPropertyFields()
|
||||
{
|
||||
Initialize();
|
||||
CheckNullProperties();
|
||||
serializedObject.Update();
|
||||
EditorGUILayout.PropertyField(m_RunInBackgroundProperty);
|
||||
EditorGUILayout.PropertyField(m_LogLevelProperty);
|
||||
EditorGUILayout.Space();
|
||||
|
||||
#if !MULTIPLAYER_TOOLS
|
||||
DrawInstallMultiplayerToolsTip();
|
||||
#endif
|
||||
EditorGUILayout.PropertyField(m_PlayerPrefabProperty);
|
||||
EditorGUILayout.Space();
|
||||
|
||||
if (!m_NetworkManager.IsServer && !m_NetworkManager.IsClient)
|
||||
DrawPrefabListField();
|
||||
|
||||
EditorGUILayout.Space();
|
||||
|
||||
EditorGUILayout.LabelField("General", EditorStyles.boldLabel);
|
||||
EditorGUILayout.PropertyField(m_ProtocolVersionProperty);
|
||||
|
||||
DrawTransportField();
|
||||
|
||||
EditorGUILayout.PropertyField(m_TickRateProperty);
|
||||
|
||||
EditorGUILayout.LabelField("Performance", EditorStyles.boldLabel);
|
||||
|
||||
EditorGUILayout.PropertyField(m_EnsureNetworkVariableLengthSafetyProperty);
|
||||
|
||||
EditorGUILayout.LabelField("Connection", EditorStyles.boldLabel);
|
||||
EditorGUILayout.PropertyField(m_ConnectionApprovalProperty);
|
||||
|
||||
using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.ConnectionApproval))
|
||||
{
|
||||
serializedObject.Update();
|
||||
EditorGUILayout.PropertyField(m_RunInBackgroundProperty);
|
||||
EditorGUILayout.PropertyField(m_LogLevelProperty);
|
||||
EditorGUILayout.Space();
|
||||
|
||||
EditorGUILayout.PropertyField(m_PlayerPrefabProperty);
|
||||
EditorGUILayout.Space();
|
||||
|
||||
if (m_NetworkManager.NetworkConfig.HasOldPrefabList())
|
||||
{
|
||||
EditorGUILayout.HelpBox("Network Prefabs serialized in old format. Migrate to new format to edit the list.", MessageType.Info);
|
||||
if (GUILayout.Button(new GUIContent("Migrate Prefab List", "Converts the old format Network Prefab list to a new Scriptable Object")))
|
||||
{
|
||||
// Default directory
|
||||
var directory = "Assets/";
|
||||
var assetPath = AssetDatabase.GetAssetPath(m_NetworkManager);
|
||||
if (assetPath == "")
|
||||
{
|
||||
assetPath = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(m_NetworkManager);
|
||||
}
|
||||
|
||||
if (assetPath != "")
|
||||
{
|
||||
directory = Path.GetDirectoryName(assetPath);
|
||||
}
|
||||
else
|
||||
{
|
||||
#if UNITY_2021_1_OR_NEWER
|
||||
var prefabStage = UnityEditor.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
|
||||
#else
|
||||
var prefabStage = UnityEditor.Experimental.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
|
||||
#endif
|
||||
if (prefabStage != null)
|
||||
{
|
||||
var prefabPath = prefabStage.assetPath;
|
||||
if (!string.IsNullOrEmpty(prefabPath))
|
||||
{
|
||||
directory = Path.GetDirectoryName(prefabPath);
|
||||
}
|
||||
}
|
||||
if (m_NetworkManager.gameObject.scene != null)
|
||||
{
|
||||
var scenePath = m_NetworkManager.gameObject.scene.path;
|
||||
if (!string.IsNullOrEmpty(scenePath))
|
||||
{
|
||||
directory = Path.GetDirectoryName(scenePath);
|
||||
}
|
||||
}
|
||||
}
|
||||
var networkPrefabs = m_NetworkManager.NetworkConfig.MigrateOldNetworkPrefabsToNetworkPrefabsList();
|
||||
string path = Path.Combine(directory, $"NetworkPrefabs-{m_NetworkManager.GetInstanceID()}.asset");
|
||||
Debug.Log("Saving migrated Network Prefabs List to " + path);
|
||||
AssetDatabase.CreateAsset(networkPrefabs, path);
|
||||
EditorUtility.SetDirty(m_NetworkManager);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (m_NetworkManager.NetworkConfig.Prefabs.NetworkPrefabsLists.Count == 0)
|
||||
{
|
||||
EditorGUILayout.HelpBox("You have no prefab list selected. You will have to add your prefabs manually at runtime for netcode to work.", MessageType.Warning);
|
||||
}
|
||||
EditorGUILayout.PropertyField(m_PrefabsList);
|
||||
}
|
||||
EditorGUILayout.Space();
|
||||
|
||||
EditorGUILayout.LabelField("General", EditorStyles.boldLabel);
|
||||
EditorGUILayout.PropertyField(m_ProtocolVersionProperty);
|
||||
|
||||
EditorGUILayout.PropertyField(m_NetworkTransportProperty);
|
||||
|
||||
if (m_NetworkTransportProperty.objectReferenceValue == null)
|
||||
{
|
||||
EditorGUILayout.HelpBox("You have no transport selected. A transport is required for netcode to work. Which one do you want?", MessageType.Warning);
|
||||
|
||||
int selection = EditorGUILayout.Popup(0, m_TransportNames);
|
||||
|
||||
if (selection > 0)
|
||||
{
|
||||
ReloadTransports();
|
||||
|
||||
var transportComponent = m_NetworkManager.gameObject.GetComponent(m_TransportTypes[selection - 1]) ?? m_NetworkManager.gameObject.AddComponent(m_TransportTypes[selection - 1]);
|
||||
m_NetworkTransportProperty.objectReferenceValue = transportComponent;
|
||||
|
||||
Repaint();
|
||||
}
|
||||
}
|
||||
|
||||
EditorGUILayout.PropertyField(m_TickRateProperty);
|
||||
|
||||
EditorGUILayout.LabelField("Performance", EditorStyles.boldLabel);
|
||||
|
||||
EditorGUILayout.PropertyField(m_EnsureNetworkVariableLengthSafetyProperty);
|
||||
|
||||
EditorGUILayout.LabelField("Connection", EditorStyles.boldLabel);
|
||||
EditorGUILayout.PropertyField(m_ConnectionApprovalProperty);
|
||||
|
||||
using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.ConnectionApproval))
|
||||
{
|
||||
EditorGUILayout.PropertyField(m_ClientConnectionBufferTimeoutProperty);
|
||||
}
|
||||
|
||||
EditorGUILayout.LabelField("Spawning", EditorStyles.boldLabel);
|
||||
EditorGUILayout.PropertyField(m_ForceSamePrefabsProperty);
|
||||
|
||||
|
||||
EditorGUILayout.PropertyField(m_RecycleNetworkIdsProperty);
|
||||
|
||||
using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.RecycleNetworkIds))
|
||||
{
|
||||
EditorGUILayout.PropertyField(m_NetworkIdRecycleDelayProperty);
|
||||
}
|
||||
|
||||
EditorGUILayout.LabelField("Bandwidth", EditorStyles.boldLabel);
|
||||
EditorGUILayout.PropertyField(m_RpcHashSizeProperty);
|
||||
|
||||
EditorGUILayout.LabelField("Scene Management", EditorStyles.boldLabel);
|
||||
EditorGUILayout.PropertyField(m_EnableSceneManagementProperty);
|
||||
|
||||
using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.EnableSceneManagement))
|
||||
{
|
||||
EditorGUILayout.PropertyField(m_LoadSceneTimeOutProperty);
|
||||
}
|
||||
|
||||
serializedObject.ApplyModifiedProperties();
|
||||
|
||||
|
||||
// Start buttons below
|
||||
{
|
||||
string buttonDisabledReasonSuffix = "";
|
||||
|
||||
if (!EditorApplication.isPlaying)
|
||||
{
|
||||
buttonDisabledReasonSuffix = ". This can only be done in play mode";
|
||||
GUI.enabled = false;
|
||||
}
|
||||
|
||||
if (GUILayout.Button(new GUIContent("Start Host", "Starts a host instance" + buttonDisabledReasonSuffix)))
|
||||
{
|
||||
m_NetworkManager.StartHost();
|
||||
}
|
||||
|
||||
if (GUILayout.Button(new GUIContent("Start Server", "Starts a server instance" + buttonDisabledReasonSuffix)))
|
||||
{
|
||||
m_NetworkManager.StartServer();
|
||||
}
|
||||
|
||||
if (GUILayout.Button(new GUIContent("Start Client", "Starts a client instance" + buttonDisabledReasonSuffix)))
|
||||
{
|
||||
m_NetworkManager.StartClient();
|
||||
}
|
||||
|
||||
if (!EditorApplication.isPlaying)
|
||||
{
|
||||
GUI.enabled = true;
|
||||
}
|
||||
}
|
||||
EditorGUILayout.PropertyField(m_ClientConnectionBufferTimeoutProperty);
|
||||
}
|
||||
else
|
||||
|
||||
EditorGUILayout.LabelField("Spawning", EditorStyles.boldLabel);
|
||||
EditorGUILayout.PropertyField(m_ForceSamePrefabsProperty);
|
||||
|
||||
EditorGUILayout.PropertyField(m_RecycleNetworkIdsProperty);
|
||||
|
||||
using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.RecycleNetworkIds))
|
||||
{
|
||||
string instanceType = string.Empty;
|
||||
EditorGUILayout.PropertyField(m_NetworkIdRecycleDelayProperty);
|
||||
}
|
||||
|
||||
if (m_NetworkManager.IsHost)
|
||||
{
|
||||
instanceType = "Host";
|
||||
}
|
||||
else if (m_NetworkManager.IsServer)
|
||||
{
|
||||
instanceType = "Server";
|
||||
}
|
||||
else if (m_NetworkManager.IsClient)
|
||||
{
|
||||
instanceType = "Client";
|
||||
}
|
||||
EditorGUILayout.LabelField("Bandwidth", EditorStyles.boldLabel);
|
||||
EditorGUILayout.PropertyField(m_RpcHashSizeProperty);
|
||||
|
||||
EditorGUILayout.HelpBox("You cannot edit the NetworkConfig when a " + instanceType + " is running.", MessageType.Info);
|
||||
EditorGUILayout.LabelField("Scene Management", EditorStyles.boldLabel);
|
||||
EditorGUILayout.PropertyField(m_EnableSceneManagementProperty);
|
||||
|
||||
if (GUILayout.Button(new GUIContent("Stop " + instanceType, "Stops the " + instanceType + " instance.")))
|
||||
using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.EnableSceneManagement))
|
||||
{
|
||||
EditorGUILayout.PropertyField(m_LoadSceneTimeOutProperty);
|
||||
}
|
||||
|
||||
serializedObject.ApplyModifiedProperties();
|
||||
}
|
||||
|
||||
private void DrawTransportField()
|
||||
{
|
||||
#if RELAY_INTEGRATION_AVAILABLE
|
||||
var useRelay = EditorPrefs.GetBool(m_UseEasyRelayIntegrationKey, false);
|
||||
#else
|
||||
var useRelay = false;
|
||||
#endif
|
||||
|
||||
if (useRelay)
|
||||
{
|
||||
EditorGUILayout.HelpBox("Test connection with relay is enabled, so the default Unity Transport will be used", MessageType.Info);
|
||||
GUI.enabled = false;
|
||||
EditorGUILayout.PropertyField(m_NetworkTransportProperty);
|
||||
GUI.enabled = true;
|
||||
return;
|
||||
}
|
||||
|
||||
EditorGUILayout.PropertyField(m_NetworkTransportProperty);
|
||||
|
||||
if (m_NetworkTransportProperty.objectReferenceValue == null)
|
||||
{
|
||||
EditorGUILayout.HelpBox("You have no transport selected. A transport is required for netcode to work. Which one do you want?", MessageType.Warning);
|
||||
|
||||
int selection = EditorGUILayout.Popup(0, m_TransportNames);
|
||||
|
||||
if (selection > 0)
|
||||
{
|
||||
m_NetworkManager.Shutdown();
|
||||
ReloadTransports();
|
||||
|
||||
var transportComponent = m_NetworkManager.gameObject.GetComponent(m_TransportTypes[selection - 1]) ?? m_NetworkManager.gameObject.AddComponent(m_TransportTypes[selection - 1]);
|
||||
m_NetworkTransportProperty.objectReferenceValue = transportComponent;
|
||||
|
||||
Repaint();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#if RELAY_INTEGRATION_AVAILABLE
|
||||
private readonly string m_UseEasyRelayIntegrationKey = "NetworkManagerUI_UseRelay_" + Application.dataPath.GetHashCode();
|
||||
private string m_JoinCode = "";
|
||||
private string m_StartConnectionError = null;
|
||||
private string m_Region = "";
|
||||
|
||||
// wait for next frame so that ImGui finishes the current frame
|
||||
private static void RunNextFrame(Action action) => EditorApplication.delayCall += () => action();
|
||||
#endif
|
||||
|
||||
private void ShowStartConnectionButtons()
|
||||
{
|
||||
EditorGUILayout.LabelField("Start Connection", EditorStyles.boldLabel);
|
||||
|
||||
#if RELAY_INTEGRATION_AVAILABLE
|
||||
// use editor prefs to persist the setting when entering / leaving play mode / exiting Unity
|
||||
var useRelay = EditorPrefs.GetBool(m_UseEasyRelayIntegrationKey, false);
|
||||
GUILayout.BeginHorizontal();
|
||||
useRelay = GUILayout.Toggle(useRelay, "Try Relay in the Editor");
|
||||
|
||||
var icon = EditorGUIUtility.IconContent("_Help");
|
||||
icon.tooltip = "This will help you test relay in the Editor. Click here to know how to integrate Relay in your build";
|
||||
if (GUILayout.Button(icon, GUIStyle.none, GUILayout.Width(20)))
|
||||
{
|
||||
Application.OpenURL("https://docs-multiplayer.unity3d.com/netcode/current/relay/");
|
||||
}
|
||||
GUILayout.EndHorizontal();
|
||||
|
||||
EditorPrefs.SetBool(m_UseEasyRelayIntegrationKey, useRelay);
|
||||
if (useRelay && !Application.isPlaying && !CloudProjectSettings.projectBound)
|
||||
{
|
||||
EditorGUILayout.HelpBox("To use relay, you need to setup your project in the Project Settings in the Services section.", MessageType.Warning);
|
||||
if (GUILayout.Button("Open Project settings"))
|
||||
{
|
||||
SettingsService.OpenProjectSettings("Project/Services");
|
||||
}
|
||||
}
|
||||
#else
|
||||
var useRelay = false;
|
||||
#endif
|
||||
|
||||
string buttonDisabledReasonSuffix = "";
|
||||
|
||||
if (!EditorApplication.isPlaying)
|
||||
{
|
||||
buttonDisabledReasonSuffix = ". This can only be done in play mode";
|
||||
GUI.enabled = false;
|
||||
}
|
||||
|
||||
if (useRelay)
|
||||
{
|
||||
ShowStartConnectionButtons_Relay(buttonDisabledReasonSuffix);
|
||||
}
|
||||
else
|
||||
{
|
||||
ShowStartConnectionButtons_Standard(buttonDisabledReasonSuffix);
|
||||
}
|
||||
|
||||
if (!EditorApplication.isPlaying)
|
||||
{
|
||||
GUI.enabled = true;
|
||||
}
|
||||
}
|
||||
|
||||
private void ShowStartConnectionButtons_Relay(string buttonDisabledReasonSuffix)
|
||||
{
|
||||
#if RELAY_INTEGRATION_AVAILABLE
|
||||
|
||||
void AddStartServerOrHostButton(bool isServer)
|
||||
{
|
||||
var type = isServer ? "Server" : "Host";
|
||||
if (GUILayout.Button(new GUIContent($"Start {type}", $"Starts a {type} instance with Relay{buttonDisabledReasonSuffix}")))
|
||||
{
|
||||
m_StartConnectionError = null;
|
||||
RunNextFrame(async () =>
|
||||
{
|
||||
try
|
||||
{
|
||||
var (joinCode, allocation) = isServer ? await m_NetworkManager.StartServerWithRelay() : await m_NetworkManager.StartHostWithRelay();
|
||||
m_JoinCode = joinCode;
|
||||
m_Region = allocation.Region;
|
||||
Repaint();
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
m_StartConnectionError = e.Message;
|
||||
throw;
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
AddStartServerOrHostButton(isServer: true);
|
||||
AddStartServerOrHostButton(isServer: false);
|
||||
|
||||
GUILayout.Space(8f);
|
||||
m_JoinCode = EditorGUILayout.TextField("Relay Join Code", m_JoinCode);
|
||||
if (GUILayout.Button(new GUIContent("Start Client", "Starts a client instance with Relay" + buttonDisabledReasonSuffix)))
|
||||
{
|
||||
m_StartConnectionError = null;
|
||||
RunNextFrame(async () =>
|
||||
{
|
||||
if (string.IsNullOrEmpty(m_JoinCode))
|
||||
{
|
||||
m_StartConnectionError = "Please provide a join code!";
|
||||
return;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
var allocation = await m_NetworkManager.StartClientWithRelay(m_JoinCode);
|
||||
m_Region = allocation.Region;
|
||||
Repaint();
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
m_StartConnectionError = e.Message;
|
||||
throw;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
if (Application.isPlaying && !string.IsNullOrEmpty(m_StartConnectionError))
|
||||
{
|
||||
EditorGUILayout.HelpBox(m_StartConnectionError, MessageType.Error);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
private void ShowStartConnectionButtons_Standard(string buttonDisabledReasonSuffix)
|
||||
{
|
||||
if (GUILayout.Button(new GUIContent("Start Host", "Starts a host instance" + buttonDisabledReasonSuffix)))
|
||||
{
|
||||
m_NetworkManager.StartHost();
|
||||
}
|
||||
|
||||
if (GUILayout.Button(new GUIContent("Start Server", "Starts a server instance" + buttonDisabledReasonSuffix)))
|
||||
{
|
||||
m_NetworkManager.StartServer();
|
||||
}
|
||||
|
||||
if (GUILayout.Button(new GUIContent("Start Client", "Starts a client instance" + buttonDisabledReasonSuffix)))
|
||||
{
|
||||
m_NetworkManager.StartClient();
|
||||
}
|
||||
}
|
||||
|
||||
private void DrawDisconnectButton()
|
||||
{
|
||||
string instanceType = string.Empty;
|
||||
|
||||
if (m_NetworkManager.IsHost)
|
||||
{
|
||||
instanceType = "Host";
|
||||
}
|
||||
else if (m_NetworkManager.IsServer)
|
||||
{
|
||||
instanceType = "Server";
|
||||
}
|
||||
else if (m_NetworkManager.IsClient)
|
||||
{
|
||||
instanceType = "Client";
|
||||
}
|
||||
|
||||
EditorGUILayout.HelpBox($"You cannot edit the NetworkConfig when a {instanceType} is running.", MessageType.Info);
|
||||
|
||||
#if RELAY_INTEGRATION_AVAILABLE
|
||||
if (!string.IsNullOrEmpty(m_JoinCode) && !string.IsNullOrEmpty(m_Region))
|
||||
{
|
||||
var style = new GUIStyle(EditorStyles.helpBox)
|
||||
{
|
||||
fontSize = 10,
|
||||
alignment = TextAnchor.MiddleCenter,
|
||||
};
|
||||
|
||||
GUILayout.BeginHorizontal(style, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false), GUILayout.MaxWidth(800));
|
||||
GUILayout.Label(new GUIContent(EditorGUIUtility.IconContent(k_InfoIconName)), GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true));
|
||||
GUILayout.Space(25f);
|
||||
GUILayout.BeginVertical();
|
||||
GUILayout.Space(4f);
|
||||
GUILayout.Label($"Connected via relay ({m_Region}).\nJoin code: {m_JoinCode}", EditorStyles.miniLabel, GUILayout.ExpandHeight(true));
|
||||
|
||||
if (GUILayout.Button("Copy code", GUILayout.ExpandHeight(true)))
|
||||
{
|
||||
GUIUtility.systemCopyBuffer = m_JoinCode;
|
||||
}
|
||||
|
||||
GUILayout.Space(4f);
|
||||
GUILayout.EndVertical();
|
||||
GUILayout.Space(2f);
|
||||
GUILayout.EndHorizontal();
|
||||
}
|
||||
#endif
|
||||
|
||||
if (GUILayout.Button(new GUIContent($"Stop {instanceType}", $"Stops the {instanceType} instance.")))
|
||||
{
|
||||
#if RELAY_INTEGRATION_AVAILABLE
|
||||
m_JoinCode = "";
|
||||
#endif
|
||||
m_NetworkManager.Shutdown();
|
||||
}
|
||||
}
|
||||
|
||||
private const string k_InfoIconName = "console.infoicon";
|
||||
private static void DrawInstallMultiplayerToolsTip()
|
||||
{
|
||||
const string getToolsText = "Access additional tools for multiplayer development by installing the Multiplayer Tools package in the Package Manager.";
|
||||
const string openDocsButtonText = "Open Docs";
|
||||
const string dismissButtonText = "Dismiss";
|
||||
const string targetUrl = "https://docs-multiplayer.unity3d.com/tools/current/install-tools";
|
||||
const string infoIconName = "console.infoicon";
|
||||
|
||||
|
||||
if (NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() != 0)
|
||||
{
|
||||
@@ -371,7 +497,7 @@ namespace Unity.Netcode.Editor
|
||||
GUILayout.FlexibleSpace();
|
||||
GUILayout.BeginHorizontal(s_HelpBoxStyle, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false), GUILayout.MaxWidth(800));
|
||||
{
|
||||
GUILayout.Label(new GUIContent(EditorGUIUtility.IconContent(infoIconName)), GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true));
|
||||
GUILayout.Label(new GUIContent(EditorGUIUtility.IconContent(k_InfoIconName)), GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true));
|
||||
GUILayout.Space(4);
|
||||
GUILayout.Label(getToolsText, s_CenteredWordWrappedLabelStyle, GUILayout.ExpandHeight(true));
|
||||
|
||||
@@ -404,5 +530,69 @@ namespace Unity.Netcode.Editor
|
||||
|
||||
GUILayout.Space(10);
|
||||
}
|
||||
|
||||
private void DrawPrefabListField()
|
||||
{
|
||||
if (!m_NetworkManager.NetworkConfig.HasOldPrefabList())
|
||||
{
|
||||
if (m_NetworkManager.NetworkConfig.Prefabs.NetworkPrefabsLists.Count == 0)
|
||||
{
|
||||
EditorGUILayout.HelpBox("You have no prefab list selected. You will have to add your prefabs manually at runtime for netcode to work.", MessageType.Warning);
|
||||
}
|
||||
|
||||
EditorGUILayout.PropertyField(m_PrefabsList);
|
||||
return;
|
||||
}
|
||||
|
||||
// Old format of prefab list
|
||||
EditorGUILayout.HelpBox("Network Prefabs serialized in old format. Migrate to new format to edit the list.", MessageType.Info);
|
||||
if (GUILayout.Button(new GUIContent("Migrate Prefab List", "Converts the old format Network Prefab list to a new Scriptable Object")))
|
||||
{
|
||||
// Default directory
|
||||
var directory = "Assets/";
|
||||
var assetPath = AssetDatabase.GetAssetPath(m_NetworkManager);
|
||||
if (assetPath == "")
|
||||
{
|
||||
assetPath = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(m_NetworkManager);
|
||||
}
|
||||
|
||||
if (assetPath != "")
|
||||
{
|
||||
directory = Path.GetDirectoryName(assetPath);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
#if UNITY_2021_1_OR_NEWER
|
||||
var prefabStage = UnityEditor.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
|
||||
#else
|
||||
var prefabStage = UnityEditor.Experimental.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
|
||||
#endif
|
||||
if (prefabStage != null)
|
||||
{
|
||||
var prefabPath = prefabStage.assetPath;
|
||||
if (!string.IsNullOrEmpty(prefabPath))
|
||||
{
|
||||
directory = Path.GetDirectoryName(prefabPath);
|
||||
}
|
||||
}
|
||||
|
||||
if (m_NetworkManager.gameObject.scene != null)
|
||||
{
|
||||
var scenePath = m_NetworkManager.gameObject.scene.path;
|
||||
if (!string.IsNullOrEmpty(scenePath))
|
||||
{
|
||||
directory = Path.GetDirectoryName(scenePath);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var networkPrefabs = m_NetworkManager.NetworkConfig.MigrateOldNetworkPrefabsToNetworkPrefabsList();
|
||||
string path = Path.Combine(directory, $"NetworkPrefabs-{m_NetworkManager.GetInstanceID()}.asset");
|
||||
Debug.Log("Saving migrated Network Prefabs List to " + path);
|
||||
AssetDatabase.CreateAsset(networkPrefabs, path);
|
||||
EditorUtility.SetDirty(m_NetworkManager);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
120
Editor/NetworkManagerRelayIntegration.cs
Normal file
120
Editor/NetworkManagerRelayIntegration.cs
Normal file
@@ -0,0 +1,120 @@
|
||||
#if UNITY_2022_3_OR_NEWER && (RELAY_SDK_INSTALLED && !UNITY_WEBGL ) || (RELAY_SDK_INSTALLED && UNITY_WEBGL && UTP_TRANSPORT_2_0_ABOVE)
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
using Unity.Netcode.Transports.UTP;
|
||||
using Unity.Networking.Transport.Relay;
|
||||
using Unity.Services.Authentication;
|
||||
using Unity.Services.Core;
|
||||
using Unity.Services.Relay;
|
||||
using Unity.Services.Relay.Models;
|
||||
|
||||
namespace Unity.Netcode.Editor
|
||||
{
|
||||
/// <summary>
|
||||
/// Integration with Unity Relay SDK and Unity Transport that support the additional buttons in the NetworkManager inspector.
|
||||
/// This code could theoretically be used at runtime, but we would like to avoid the additional dependencies in the runtime assembly of netcode for gameobjects.
|
||||
/// </summary>
|
||||
public static class NetworkManagerRelayIntegration
|
||||
{
|
||||
|
||||
#if UNITY_WEBGL
|
||||
private const string k_DefaultConnectionType = "wss";
|
||||
#else
|
||||
private const string k_DefaultConnectionType = "dtls";
|
||||
#endif
|
||||
|
||||
/// <summary>
|
||||
/// Easy relay integration (host): it will initialize the unity services, sign in anonymously and start the host with a new relay allocation.
|
||||
/// Note that this will force the use of Unity Transport.
|
||||
/// </summary>
|
||||
/// <param name="networkManager">The network manager that will start the connection</param>
|
||||
/// <param name="maxConnections">Maximum number of connections to the created relay.</param>
|
||||
/// <param name="connectionType">The connection type of the <see cref="RelayServerData"/> (wss, ws, dtls or udp) </param>
|
||||
/// <returns>The join code that a potential client can use and the allocation</returns>
|
||||
/// <exception cref="ServicesInitializationException"> Exception when there's an error during services initialization </exception>
|
||||
/// <exception cref="UnityProjectNotLinkedException"> Exception when the project is not linked to a cloud project id </exception>
|
||||
/// <exception cref="CircularDependencyException"> Exception when two registered <see cref="IInitializablePackage"/> depend on the other </exception>
|
||||
/// <exception cref="AuthenticationException"> The task fails with the exception when the task cannot complete successfully due to Authentication specific errors. </exception>
|
||||
/// <exception cref="RequestFailedException"> See <see cref="IAuthenticationService.SignInAnonymouslyAsync"/></exception>
|
||||
/// <exception cref="ArgumentException">Thrown when the maxConnections argument fails validation in Relay Service SDK.</exception>
|
||||
/// <exception cref="RelayServiceException">Thrown when the request successfully reach the Relay Allocation Service but results in an error.</exception>
|
||||
internal static async Task<(string, Allocation)> StartHostWithRelay(this NetworkManager networkManager, int maxConnections = 5)
|
||||
{
|
||||
var codeAndAllocation = await InitializeAndCreateAllocAsync(networkManager, maxConnections, k_DefaultConnectionType);
|
||||
return networkManager.StartHost() ? codeAndAllocation : (null, null);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Easy relay integration (server): it will initialize the unity services, sign in anonymously and start the server with a new relay allocation.
|
||||
/// Note that this will force the use of Unity Transport.
|
||||
/// </summary>
|
||||
/// <param name="networkManager">The network manager that will start the connection</param>
|
||||
/// <param name="maxConnections">Maximum number of connections to the created relay.</param>
|
||||
/// <returns>The join code that a potential client can use and the allocation.</returns>
|
||||
/// <exception cref="ServicesInitializationException"> Exception when there's an error during services initialization </exception>
|
||||
/// <exception cref="UnityProjectNotLinkedException"> Exception when the project is not linked to a cloud project id </exception>
|
||||
/// <exception cref="CircularDependencyException"> Exception when two registered <see cref="IInitializablePackage"/> depend on the other </exception>
|
||||
/// <exception cref="AuthenticationException"> The task fails with the exception when the task cannot complete successfully due to Authentication specific errors. </exception>
|
||||
/// <exception cref="RequestFailedException"> See <see cref="IAuthenticationService.SignInAnonymouslyAsync"/></exception>
|
||||
/// <exception cref="ArgumentException">Thrown when the maxConnections argument fails validation in Relay Service SDK.</exception>
|
||||
/// <exception cref="RelayServiceException">Thrown when the request successfully reach the Relay Allocation Service but results in an error.</exception>
|
||||
internal static async Task<(string, Allocation)> StartServerWithRelay(this NetworkManager networkManager, int maxConnections = 5)
|
||||
{
|
||||
var codeAndAllocation = await InitializeAndCreateAllocAsync(networkManager, maxConnections, k_DefaultConnectionType);
|
||||
return networkManager.StartServer() ? codeAndAllocation : (null, null);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Easy relay integration (client): it will initialize the unity services, sign in anonymously, join the relay with the given join code and start the client.
|
||||
/// Note that this will force the use of Unity Transport.
|
||||
/// </summary>
|
||||
/// <param name="networkManager">The network manager that will start the connection</param>
|
||||
/// <param name="joinCode">The join code of the allocation</param>
|
||||
/// <exception cref="ServicesInitializationException"> Exception when there's an error during services initialization </exception>
|
||||
/// <exception cref="UnityProjectNotLinkedException"> Exception when the project is not linked to a cloud project id </exception>
|
||||
/// <exception cref="CircularDependencyException"> Exception when two registered <see cref="IInitializablePackage"/> depend on the other </exception>
|
||||
/// <exception cref="AuthenticationException"> The task fails with the exception when the task cannot complete successfully due to Authentication specific errors. </exception>
|
||||
/// <exception cref="RequestFailedException">Thrown when the request does not reach the Relay Allocation Service.</exception>
|
||||
/// <exception cref="ArgumentException">Thrown if the joinCode has the wrong format.</exception>
|
||||
/// <exception cref="RelayServiceException">Thrown when the request successfully reach the Relay Allocation Service but results in an error.</exception>
|
||||
/// <returns>True if starting the client was successful</returns>
|
||||
internal static async Task<JoinAllocation> StartClientWithRelay(this NetworkManager networkManager, string joinCode)
|
||||
{
|
||||
await UnityServices.InitializeAsync();
|
||||
if (!AuthenticationService.Instance.IsSignedIn)
|
||||
{
|
||||
await AuthenticationService.Instance.SignInAnonymouslyAsync();
|
||||
}
|
||||
var joinAllocation = await RelayService.Instance.JoinAllocationAsync(joinCode: joinCode);
|
||||
GetUnityTransport(networkManager, k_DefaultConnectionType).SetRelayServerData(new RelayServerData(joinAllocation, k_DefaultConnectionType));
|
||||
return networkManager.StartClient() ? joinAllocation : null;
|
||||
}
|
||||
|
||||
private static async Task<(string, Allocation)> InitializeAndCreateAllocAsync(NetworkManager networkManager, int maxConnections, string connectionType)
|
||||
{
|
||||
await UnityServices.InitializeAsync();
|
||||
if (!AuthenticationService.Instance.IsSignedIn)
|
||||
{
|
||||
await AuthenticationService.Instance.SignInAnonymouslyAsync();
|
||||
}
|
||||
Allocation allocation = await RelayService.Instance.CreateAllocationAsync(maxConnections);
|
||||
GetUnityTransport(networkManager, connectionType).SetRelayServerData(new RelayServerData(allocation, connectionType));
|
||||
var joinCode = await RelayService.Instance.GetJoinCodeAsync(allocation.AllocationId);
|
||||
return (joinCode, allocation);
|
||||
}
|
||||
|
||||
private static UnityTransport GetUnityTransport(NetworkManager networkManager, string connectionType)
|
||||
{
|
||||
if (!networkManager.TryGetComponent<UnityTransport>(out var transport))
|
||||
{
|
||||
transport = networkManager.gameObject.AddComponent<UnityTransport>();
|
||||
}
|
||||
#if UTP_TRANSPORT_2_0_ABOVE
|
||||
transport.UseWebSockets = connectionType.StartsWith("ws"); // Probably should be part of SetRelayServerData, but not possible at this point
|
||||
#endif
|
||||
networkManager.NetworkConfig.NetworkTransport = transport; // Force using UnityTransport
|
||||
return transport;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
3
Editor/NetworkManagerRelayIntegration.cs.meta
Normal file
3
Editor/NetworkManagerRelayIntegration.cs.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 23b658b1c2e443109a8a131ef3632c9b
|
||||
timeCreated: 1698673251
|
||||
@@ -10,6 +10,7 @@ namespace Unity.Netcode.Editor
|
||||
[CustomEditor(typeof(NetworkTransform), true)]
|
||||
public class NetworkTransformEditor : UnityEditor.Editor
|
||||
{
|
||||
private SerializedProperty m_UseUnreliableDeltas;
|
||||
private SerializedProperty m_SyncPositionXProperty;
|
||||
private SerializedProperty m_SyncPositionYProperty;
|
||||
private SerializedProperty m_SyncPositionZProperty;
|
||||
@@ -36,9 +37,12 @@ namespace Unity.Netcode.Editor
|
||||
private static GUIContent s_RotationLabel = EditorGUIUtility.TrTextContent("Rotation");
|
||||
private static GUIContent s_ScaleLabel = EditorGUIUtility.TrTextContent("Scale");
|
||||
|
||||
public virtual bool HideInterpolateValue => false;
|
||||
|
||||
/// <inheritdoc/>
|
||||
public void OnEnable()
|
||||
{
|
||||
m_UseUnreliableDeltas = serializedObject.FindProperty(nameof(NetworkTransform.UseUnreliableDeltas));
|
||||
m_SyncPositionXProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionX));
|
||||
m_SyncPositionYProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionY));
|
||||
m_SyncPositionZProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionZ));
|
||||
@@ -129,11 +133,17 @@ namespace Unity.Netcode.Editor
|
||||
EditorGUILayout.PropertyField(m_PositionThresholdProperty);
|
||||
EditorGUILayout.PropertyField(m_RotAngleThresholdProperty);
|
||||
EditorGUILayout.PropertyField(m_ScaleThresholdProperty);
|
||||
|
||||
EditorGUILayout.Space();
|
||||
EditorGUILayout.LabelField("Delivery", EditorStyles.boldLabel);
|
||||
EditorGUILayout.PropertyField(m_UseUnreliableDeltas);
|
||||
EditorGUILayout.Space();
|
||||
EditorGUILayout.LabelField("Configurations", EditorStyles.boldLabel);
|
||||
EditorGUILayout.PropertyField(m_InLocalSpaceProperty);
|
||||
EditorGUILayout.PropertyField(m_InterpolateProperty);
|
||||
if (!HideInterpolateValue)
|
||||
{
|
||||
EditorGUILayout.PropertyField(m_InterpolateProperty);
|
||||
}
|
||||
|
||||
EditorGUILayout.PropertyField(m_SlerpPosition);
|
||||
EditorGUILayout.PropertyField(m_UseQuaternionSynchronization);
|
||||
if (m_UseQuaternionSynchronization.boolValue)
|
||||
@@ -146,9 +156,10 @@ namespace Unity.Netcode.Editor
|
||||
}
|
||||
EditorGUILayout.PropertyField(m_UseHalfFloatPrecision);
|
||||
|
||||
#if COM_UNITY_MODULES_PHYSICS
|
||||
// if rigidbody is present but network rigidbody is not present
|
||||
var go = ((NetworkTransform)target).gameObject;
|
||||
|
||||
#if COM_UNITY_MODULES_PHYSICS
|
||||
if (go.TryGetComponent<Rigidbody>(out _) && go.TryGetComponent<NetworkRigidbody>(out _) == false)
|
||||
{
|
||||
EditorGUILayout.HelpBox("This GameObject contains a Rigidbody but no NetworkRigidbody.\n" +
|
||||
|
||||
@@ -3,11 +3,21 @@
|
||||
"rootNamespace": "Unity.Netcode.Editor",
|
||||
"references": [
|
||||
"Unity.Netcode.Runtime",
|
||||
"Unity.Netcode.Components"
|
||||
"Unity.Netcode.Components",
|
||||
"Unity.Services.Relay",
|
||||
"Unity.Networking.Transport",
|
||||
"Unity.Services.Core",
|
||||
"Unity.Services.Authentication"
|
||||
],
|
||||
"includePlatforms": [
|
||||
"Editor"
|
||||
],
|
||||
"excludePlatforms": [],
|
||||
"allowUnsafeCode": false,
|
||||
"overrideReferences": false,
|
||||
"precompiledReferences": [],
|
||||
"autoReferenced": true,
|
||||
"defineConstraints": [],
|
||||
"versionDefines": [
|
||||
{
|
||||
"name": "com.unity.multiplayer.tools",
|
||||
@@ -33,6 +43,17 @@
|
||||
"name": "com.unity.modules.physics2d",
|
||||
"expression": "",
|
||||
"define": "COM_UNITY_MODULES_PHYSICS2D"
|
||||
},
|
||||
{
|
||||
"name": "com.unity.services.relay",
|
||||
"expression": "1.0",
|
||||
"define": "RELAY_SDK_INSTALLED"
|
||||
},
|
||||
{
|
||||
"name": "com.unity.transport",
|
||||
"expression": "2.0",
|
||||
"define": "UTP_TRANSPORT_2_0_ABOVE"
|
||||
}
|
||||
]
|
||||
}
|
||||
],
|
||||
"noEngineReferences": false
|
||||
}
|
||||
@@ -132,7 +132,7 @@ namespace Unity.Netcode
|
||||
/// The amount of time a message should be buffered if the asset or object needed to process it doesn't exist yet. If the asset is not added/object is not spawned within this time, it will be dropped.
|
||||
/// </summary>
|
||||
[Tooltip("The amount of time a message should be buffered if the asset or object needed to process it doesn't exist yet. If the asset is not added/object is not spawned within this time, it will be dropped")]
|
||||
public float SpawnTimeout = 1f;
|
||||
public float SpawnTimeout = 10f;
|
||||
|
||||
/// <summary>
|
||||
/// Whether or not to enable network logs.
|
||||
|
||||
@@ -30,6 +30,12 @@ namespace Unity.Netcode
|
||||
[NonSerialized]
|
||||
public Dictionary<uint, NetworkPrefab> NetworkPrefabOverrideLinks = new Dictionary<uint, NetworkPrefab>();
|
||||
|
||||
/// <summary>
|
||||
/// This is used for the legacy way of spawning NetworkPrefabs with an override when manually instantiating and spawning.
|
||||
/// To handle multiple source NetworkPrefab overrides that all point to the same target NetworkPrefab use
|
||||
/// <see cref="NetworkSpawnManager.InstantiateAndSpawn(NetworkObject, ulong, bool, bool, bool, Vector3, Quaternion)"/>
|
||||
/// or <see cref="NetworkObject.InstantiateAndSpawn(NetworkManager, ulong, bool, bool, bool, Vector3, Quaternion)"/>
|
||||
/// </summary>
|
||||
[NonSerialized]
|
||||
public Dictionary<uint, uint> OverrideToNetworkPrefab = new Dictionary<uint, uint>();
|
||||
|
||||
@@ -234,7 +240,8 @@ namespace Unity.Netcode
|
||||
{
|
||||
for (int i = 0; i < m_Prefabs.Count; i++)
|
||||
{
|
||||
if (m_Prefabs[i].Prefab == prefab)
|
||||
// Check both values as Prefab and be different than SourcePrefabToOverride
|
||||
if (m_Prefabs[i].Prefab == prefab || m_Prefabs[i].SourcePrefabToOverride == prefab)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
@@ -262,7 +269,7 @@ namespace Unity.Netcode
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Configures <see cref="NetworkPrefabOverrideLinks"/> and <see cref="OverrideToNetworkPrefab"/> for the given <see cref="NetworkPrefab"/>
|
||||
/// Configures <see cref="NetworkPrefabOverrideLinks"/> for the given <see cref="NetworkPrefab"/>
|
||||
/// </summary>
|
||||
private bool AddPrefabRegistration(NetworkPrefab networkPrefab)
|
||||
{
|
||||
@@ -296,28 +303,16 @@ namespace Unity.Netcode
|
||||
return true;
|
||||
}
|
||||
|
||||
// Make sure we don't have several overrides targeting the same prefab. Apparently we don't support that... shame.
|
||||
if (OverrideToNetworkPrefab.ContainsKey(target))
|
||||
{
|
||||
var networkObject = networkPrefab.Prefab.GetComponent<NetworkObject>();
|
||||
|
||||
// This can happen if a user tries to make several GlobalObjectIdHash values point to the same target
|
||||
Debug.LogError($"{nameof(NetworkPrefab)} (\"{networkObject.name}\") has a duplicate {nameof(NetworkObject.GlobalObjectIdHash)} target entry value of: {target}!");
|
||||
return false;
|
||||
}
|
||||
|
||||
switch (networkPrefab.Override)
|
||||
{
|
||||
case NetworkPrefabOverride.Prefab:
|
||||
{
|
||||
NetworkPrefabOverrideLinks.Add(source, networkPrefab);
|
||||
OverrideToNetworkPrefab.Add(target, source);
|
||||
}
|
||||
break;
|
||||
case NetworkPrefabOverride.Hash:
|
||||
{
|
||||
NetworkPrefabOverrideLinks.Add(source, networkPrefab);
|
||||
OverrideToNetworkPrefab.Add(target, source);
|
||||
if (!OverrideToNetworkPrefab.ContainsKey(target))
|
||||
{
|
||||
OverrideToNetworkPrefab.Add(target, source);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -10,6 +10,38 @@ using Object = UnityEngine.Object;
|
||||
|
||||
namespace Unity.Netcode
|
||||
{
|
||||
|
||||
public enum ConnectionEvent
|
||||
{
|
||||
ClientConnected,
|
||||
PeerConnected,
|
||||
ClientDisconnected,
|
||||
PeerDisconnected
|
||||
}
|
||||
|
||||
public struct ConnectionEventData
|
||||
{
|
||||
public ConnectionEvent EventType;
|
||||
|
||||
/// <summary>
|
||||
/// The client ID for the client that just connected
|
||||
/// For the <see cref="ConnectionEvent.ClientConnected"/> and <see cref="ConnectionEvent.ClientDisconnected"/>
|
||||
/// events on the client side, this will be LocalClientId.
|
||||
/// On the server side, this will be the ID of the client that just connected.
|
||||
///
|
||||
/// For the <see cref="ConnectionEvent.PeerConnected"/> and <see cref="ConnectionEvent.PeerDisconnected"/>
|
||||
/// events on the client side, this will be the client ID assigned by the server to the remote peer.
|
||||
/// </summary>
|
||||
public ulong ClientId;
|
||||
|
||||
/// <summary>
|
||||
/// This is only populated in <see cref="ConnectionEvent.ClientConnected"/> on the client side, and
|
||||
/// contains the list of other peers who were present before you connected. In all other situations,
|
||||
/// this array will be uninitialized.
|
||||
/// </summary>
|
||||
public NativeArray<ulong> PeerClientIds;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The NGO connection manager handles:
|
||||
/// - Client Connections
|
||||
@@ -42,7 +74,105 @@ namespace Unity.Netcode
|
||||
/// </summary>
|
||||
public event Action<ulong> OnClientDisconnectCallback = null;
|
||||
|
||||
internal void InvokeOnClientConnectedCallback(ulong clientId) => OnClientConnectedCallback?.Invoke(clientId);
|
||||
/// <summary>
|
||||
/// The callback to invoke once a peer connects. This callback is only ran on the server and on the local client that connects.
|
||||
/// </summary>
|
||||
public event Action<NetworkManager, ConnectionEventData> OnConnectionEvent = null;
|
||||
|
||||
|
||||
internal void InvokeOnClientConnectedCallback(ulong clientId)
|
||||
{
|
||||
try
|
||||
{
|
||||
OnClientConnectedCallback?.Invoke(clientId);
|
||||
}
|
||||
catch (Exception exception)
|
||||
{
|
||||
Debug.LogException(exception);
|
||||
}
|
||||
|
||||
if (!NetworkManager.IsServer)
|
||||
{
|
||||
var peerClientIds = new NativeArray<ulong>(Math.Max(NetworkManager.ConnectedClientsIds.Count - 1, 0), Allocator.Temp);
|
||||
// `using var peerClientIds` or `using(peerClientIds)` renders it immutable...
|
||||
using var sentinel = peerClientIds;
|
||||
|
||||
var idx = 0;
|
||||
foreach (var peerId in NetworkManager.ConnectedClientsIds)
|
||||
{
|
||||
if (peerId == NetworkManager.LocalClientId)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
peerClientIds[idx] = peerId;
|
||||
++idx;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
OnConnectionEvent?.Invoke(NetworkManager, new ConnectionEventData { ClientId = NetworkManager.LocalClientId, EventType = ConnectionEvent.ClientConnected, PeerClientIds = peerClientIds });
|
||||
}
|
||||
catch (Exception exception)
|
||||
{
|
||||
Debug.LogException(exception);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
try
|
||||
{
|
||||
OnConnectionEvent?.Invoke(NetworkManager, new ConnectionEventData { ClientId = clientId, EventType = ConnectionEvent.ClientConnected });
|
||||
}
|
||||
catch (Exception exception)
|
||||
{
|
||||
Debug.LogException(exception);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
internal void InvokeOnClientDisconnectCallback(ulong clientId)
|
||||
{
|
||||
try
|
||||
{
|
||||
OnClientDisconnectCallback?.Invoke(clientId);
|
||||
}
|
||||
catch (Exception exception)
|
||||
{
|
||||
Debug.LogException(exception);
|
||||
}
|
||||
try
|
||||
{
|
||||
OnConnectionEvent?.Invoke(NetworkManager, new ConnectionEventData { ClientId = clientId, EventType = ConnectionEvent.ClientDisconnected });
|
||||
}
|
||||
catch (Exception exception)
|
||||
{
|
||||
Debug.LogException(exception);
|
||||
}
|
||||
}
|
||||
|
||||
internal void InvokeOnPeerConnectedCallback(ulong clientId)
|
||||
{
|
||||
try
|
||||
{
|
||||
OnConnectionEvent?.Invoke(NetworkManager, new ConnectionEventData { ClientId = clientId, EventType = ConnectionEvent.PeerConnected });
|
||||
}
|
||||
catch (Exception exception)
|
||||
{
|
||||
Debug.LogException(exception);
|
||||
}
|
||||
}
|
||||
internal void InvokeOnPeerDisconnectedCallback(ulong clientId)
|
||||
{
|
||||
try
|
||||
{
|
||||
OnConnectionEvent?.Invoke(NetworkManager, new ConnectionEventData { ClientId = clientId, EventType = ConnectionEvent.PeerDisconnected });
|
||||
}
|
||||
catch (Exception exception)
|
||||
{
|
||||
Debug.LogException(exception);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The callback to invoke if the <see cref="NetworkTransport"/> fails.
|
||||
@@ -217,7 +347,7 @@ namespace Unity.Netcode
|
||||
// When this happens, the client will not have an entry within the m_TransportIdToClientIdMap or m_ClientIdToTransportIdMap lookup tables so we exit early and just return 0 to be used for the disconnect event.
|
||||
if (!LocalClient.IsServer && !TransportIdToClientIdMap.ContainsKey(transportId))
|
||||
{
|
||||
return 0;
|
||||
return NetworkManager.LocalClientId;
|
||||
}
|
||||
|
||||
var clientId = TransportIdToClientId(transportId);
|
||||
@@ -346,32 +476,48 @@ namespace Unity.Netcode
|
||||
s_TransportDisconnect.Begin();
|
||||
#endif
|
||||
var clientId = TransportIdCleanUp(transportClientId);
|
||||
|
||||
if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
|
||||
{
|
||||
NetworkLog.LogInfo($"Disconnect Event From {clientId}");
|
||||
}
|
||||
|
||||
// If we are a client and we have gotten the ServerClientId back, then use our assigned local id as the client that was
|
||||
// disconnected (either the user disconnected or the server disconnected, but the client that disconnected is the LocalClientId)
|
||||
if (!NetworkManager.IsServer && clientId == NetworkManager.ServerClientId)
|
||||
{
|
||||
clientId = NetworkManager.LocalClientId;
|
||||
}
|
||||
|
||||
// Process the incoming message queue so that we get everything from the server disconnecting us or, if we are the server, so we got everything from that client.
|
||||
MessageManager.ProcessIncomingMessageQueue();
|
||||
|
||||
try
|
||||
InvokeOnClientDisconnectCallback(clientId);
|
||||
|
||||
if (LocalClient.IsHost)
|
||||
{
|
||||
OnClientDisconnectCallback?.Invoke(clientId);
|
||||
}
|
||||
catch (Exception exception)
|
||||
{
|
||||
Debug.LogException(exception);
|
||||
InvokeOnPeerDisconnectedCallback(clientId);
|
||||
}
|
||||
|
||||
if (LocalClient.IsServer)
|
||||
{
|
||||
OnClientDisconnectFromServer(clientId);
|
||||
}
|
||||
else // As long as we are not in the middle of a shutdown
|
||||
if (!NetworkManager.ShutdownInProgress)
|
||||
{
|
||||
// We must pass true here and not process any sends messages as we are no longer connected.
|
||||
// Otherwise, attempting to process messages here can cause an exception within UnityTransport
|
||||
// as the client ID is no longer valid.
|
||||
NetworkManager.Shutdown(true);
|
||||
}
|
||||
|
||||
if (NetworkManager.IsServer)
|
||||
{
|
||||
MessageManager.ClientDisconnected(clientId);
|
||||
}
|
||||
else
|
||||
{
|
||||
// We must pass true here and not process any sends messages as we are no longer connected and thus there is no one to send any messages to and this will cause an exception within UnityTransport as the client ID is no longer valid.
|
||||
NetworkManager.Shutdown(true);
|
||||
MessageManager.ClientDisconnected(NetworkManager.ServerClientId);
|
||||
}
|
||||
#if DEVELOPMENT_BUILD || UNITY_EDITOR
|
||||
s_TransportDisconnect.End();
|
||||
@@ -623,8 +769,17 @@ namespace Unity.Netcode
|
||||
var message = new ConnectionApprovedMessage
|
||||
{
|
||||
OwnerClientId = ownerClientId,
|
||||
NetworkTick = NetworkManager.LocalTime.Tick
|
||||
NetworkTick = NetworkManager.LocalTime.Tick,
|
||||
ConnectedClientIds = new NativeArray<ulong>(ConnectedClientIds.Count, Allocator.Temp)
|
||||
};
|
||||
|
||||
var i = 0;
|
||||
foreach (var clientId in ConnectedClientIds)
|
||||
{
|
||||
message.ConnectedClientIds[i] = clientId;
|
||||
++i;
|
||||
}
|
||||
|
||||
if (!NetworkManager.NetworkConfig.EnableSceneManagement)
|
||||
{
|
||||
// Update the observed spawned NetworkObjects for the newly connected player when scene management is disabled
|
||||
@@ -651,12 +806,17 @@ namespace Unity.Netcode
|
||||
|
||||
SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ownerClientId);
|
||||
message.MessageVersions.Dispose();
|
||||
message.ConnectedClientIds.Dispose();
|
||||
|
||||
// If scene management is disabled, then we are done and notify the local host-server the client is connected
|
||||
if (!NetworkManager.NetworkConfig.EnableSceneManagement)
|
||||
{
|
||||
NetworkManager.ConnectedClients[ownerClientId].IsConnected = true;
|
||||
InvokeOnClientConnectedCallback(ownerClientId);
|
||||
if (LocalClient.IsHost)
|
||||
{
|
||||
InvokeOnPeerConnectedCallback(ownerClientId);
|
||||
}
|
||||
}
|
||||
else // Otherwise, let NetworkSceneManager handle the initial scene and NetworkObject synchronization
|
||||
{
|
||||
@@ -740,6 +900,8 @@ namespace Unity.Netcode
|
||||
|
||||
ConnectedClients.Add(clientId, networkClient);
|
||||
ConnectedClientsList.Add(networkClient);
|
||||
var message = new ClientConnectedMessage { ClientId = clientId };
|
||||
NetworkManager.MessageManager.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ConnectedClientIds);
|
||||
ConnectedClientIds.Add(clientId);
|
||||
return networkClient;
|
||||
}
|
||||
@@ -757,6 +919,7 @@ namespace Unity.Netcode
|
||||
|
||||
// If we are shutting down and this is the server or host disconnecting, then ignore
|
||||
// clean up as everything that needs to be destroyed will be during shutdown.
|
||||
|
||||
if (NetworkManager.ShutdownInProgress && clientId == NetworkManager.ServerClientId)
|
||||
{
|
||||
return;
|
||||
@@ -780,7 +943,7 @@ namespace Unity.Netcode
|
||||
NetworkManager.SpawnManager.DespawnObject(playerObject, true);
|
||||
}
|
||||
}
|
||||
else
|
||||
else if (!NetworkManager.ShutdownInProgress)
|
||||
{
|
||||
playerObject.RemoveOwnership();
|
||||
}
|
||||
@@ -799,7 +962,7 @@ namespace Unity.Netcode
|
||||
}
|
||||
else
|
||||
{
|
||||
// Handle changing ownership and prefab handlers
|
||||
// Handle changing ownership and prefab handlers
|
||||
for (int i = clientOwnedObjects.Count - 1; i >= 0; i--)
|
||||
{
|
||||
var ownedObject = clientOwnedObjects[i];
|
||||
@@ -816,7 +979,7 @@ namespace Unity.Netcode
|
||||
Object.Destroy(ownedObject.gameObject);
|
||||
}
|
||||
}
|
||||
else
|
||||
else if (!NetworkManager.ShutdownInProgress)
|
||||
{
|
||||
ownedObject.RemoveOwnership();
|
||||
}
|
||||
@@ -837,6 +1000,8 @@ namespace Unity.Netcode
|
||||
}
|
||||
|
||||
ConnectedClientIds.Remove(clientId);
|
||||
var message = new ClientDisconnectedMessage { ClientId = clientId };
|
||||
MessageManager?.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ConnectedClientIds);
|
||||
}
|
||||
|
||||
// If the client ID transport map exists
|
||||
@@ -845,13 +1010,11 @@ namespace Unity.Netcode
|
||||
var transportId = ClientIdToTransportId(clientId);
|
||||
NetworkManager.NetworkConfig.NetworkTransport.DisconnectRemoteClient(transportId);
|
||||
|
||||
try
|
||||
InvokeOnClientDisconnectCallback(clientId);
|
||||
|
||||
if (LocalClient.IsHost)
|
||||
{
|
||||
OnClientDisconnectCallback?.Invoke(clientId);
|
||||
}
|
||||
catch (Exception exception)
|
||||
{
|
||||
Debug.LogException(exception);
|
||||
InvokeOnPeerDisconnectedCallback(clientId);
|
||||
}
|
||||
|
||||
// Clean up the transport to client (and vice versa) mappings
|
||||
@@ -889,6 +1052,12 @@ namespace Unity.Netcode
|
||||
throw new NotServerException($"Only server can disconnect remote clients. Please use `{nameof(Shutdown)}()` instead.");
|
||||
}
|
||||
|
||||
if (clientId == NetworkManager.ServerClientId)
|
||||
{
|
||||
Debug.LogWarning($"Disconnecting the local server-host client is not allowed. Use NetworkManager.Shutdown instead.");
|
||||
return;
|
||||
}
|
||||
|
||||
if (!string.IsNullOrEmpty(reason))
|
||||
{
|
||||
var disconnectReason = new DisconnectReasonMessage
|
||||
@@ -933,13 +1102,8 @@ namespace Unity.Netcode
|
||||
/// </summary>
|
||||
internal void Shutdown()
|
||||
{
|
||||
LocalClient.IsApproved = false;
|
||||
LocalClient.IsConnected = false;
|
||||
if (LocalClient.IsServer)
|
||||
{
|
||||
// make sure all messages are flushed before transport disconnect clients
|
||||
MessageManager?.ProcessSendQueues();
|
||||
|
||||
// Build a list of all client ids to be disconnected
|
||||
var disconnectedIds = new HashSet<ulong>();
|
||||
|
||||
@@ -975,9 +1139,15 @@ namespace Unity.Netcode
|
||||
{
|
||||
DisconnectRemoteClient(clientId);
|
||||
}
|
||||
|
||||
// make sure all messages are flushed before transport disconnects clients
|
||||
MessageManager?.ProcessSendQueues();
|
||||
}
|
||||
else if (NetworkManager != null && NetworkManager.IsListening && LocalClient.IsClient)
|
||||
{
|
||||
// make sure all messages are flushed before disconnecting
|
||||
MessageManager?.ProcessSendQueues();
|
||||
|
||||
// Client only, send disconnect and if transport throws and exception, log the exception and continue the shutdown sequence (or forever be shutting down)
|
||||
try
|
||||
{
|
||||
@@ -989,6 +1159,12 @@ namespace Unity.Netcode
|
||||
}
|
||||
}
|
||||
|
||||
LocalClient.IsApproved = false;
|
||||
LocalClient.IsConnected = false;
|
||||
ConnectedClients.Clear();
|
||||
ConnectedClientIds.Clear();
|
||||
ConnectedClientsList.Clear();
|
||||
|
||||
if (NetworkManager != null && NetworkManager.NetworkConfig?.NetworkTransport != null)
|
||||
{
|
||||
NetworkManager.NetworkConfig.NetworkTransport.OnTransportEvent -= HandleNetworkEvent;
|
||||
|
||||
@@ -6,6 +6,14 @@ using UnityEngine;
|
||||
|
||||
namespace Unity.Netcode
|
||||
{
|
||||
public class RpcException : Exception
|
||||
{
|
||||
public RpcException(string message) : base(message)
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The base class to override to write network code. Inherits MonoBehaviour
|
||||
/// </summary>
|
||||
@@ -27,16 +35,22 @@ namespace Unity.Netcode
|
||||
// RuntimeAccessModifiersILPP will make this `protected`
|
||||
internal enum __RpcExecStage
|
||||
{
|
||||
// Technically will overlap with None and Server
|
||||
// but it doesn't matter since we don't use None and Server
|
||||
Send = 0,
|
||||
Execute = 1,
|
||||
|
||||
// Backward compatibility, not used...
|
||||
None = 0,
|
||||
Server = 1,
|
||||
Client = 2
|
||||
Client = 2,
|
||||
}
|
||||
// NetworkBehaviourILPP will override this in derived classes to return the name of the concrete type
|
||||
internal virtual string __getTypeName() => nameof(NetworkBehaviour);
|
||||
|
||||
[NonSerialized]
|
||||
// RuntimeAccessModifiersILPP will make this `protected`
|
||||
internal __RpcExecStage __rpc_exec_stage = __RpcExecStage.None;
|
||||
internal __RpcExecStage __rpc_exec_stage = __RpcExecStage.Send;
|
||||
#pragma warning restore IDE1006 // restore naming rule violation check
|
||||
|
||||
private const int k_RpcMessageDefaultSize = 1024; // 1k
|
||||
@@ -284,6 +298,99 @@ namespace Unity.Netcode
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
#pragma warning disable IDE1006 // disable naming rule violation check
|
||||
// RuntimeAccessModifiersILPP will make this `protected`
|
||||
internal FastBufferWriter __beginSendRpc(uint rpcMethodId, RpcParams rpcParams, RpcAttribute.RpcAttributeParams attributeParams, SendTo defaultTarget, RpcDelivery rpcDelivery)
|
||||
#pragma warning restore IDE1006 // restore naming rule violation check
|
||||
{
|
||||
if (attributeParams.RequireOwnership && !IsOwner)
|
||||
{
|
||||
throw new RpcException("This RPC can only be sent by its owner.");
|
||||
}
|
||||
return new FastBufferWriter(k_RpcMessageDefaultSize, Allocator.Temp, k_RpcMessageMaximumSize);
|
||||
}
|
||||
|
||||
#pragma warning disable IDE1006 // disable naming rule violation check
|
||||
// RuntimeAccessModifiersILPP will make this `protected`
|
||||
internal void __endSendRpc(ref FastBufferWriter bufferWriter, uint rpcMethodId, RpcParams rpcParams, RpcAttribute.RpcAttributeParams attributeParams, SendTo defaultTarget, RpcDelivery rpcDelivery)
|
||||
#pragma warning restore IDE1006 // restore naming rule violation check
|
||||
{
|
||||
var rpcMessage = new RpcMessage
|
||||
{
|
||||
Metadata = new RpcMetadata
|
||||
{
|
||||
NetworkObjectId = NetworkObjectId,
|
||||
NetworkBehaviourId = NetworkBehaviourId,
|
||||
NetworkRpcMethodId = rpcMethodId,
|
||||
},
|
||||
SenderClientId = NetworkManager.LocalClientId,
|
||||
WriteBuffer = bufferWriter
|
||||
};
|
||||
|
||||
NetworkDelivery networkDelivery;
|
||||
switch (rpcDelivery)
|
||||
{
|
||||
default:
|
||||
case RpcDelivery.Reliable:
|
||||
networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
|
||||
break;
|
||||
case RpcDelivery.Unreliable:
|
||||
if (bufferWriter.Length > NetworkManager.MessageManager.NonFragmentedMessageMaxSize)
|
||||
{
|
||||
throw new OverflowException("RPC parameters are too large for unreliable delivery.");
|
||||
}
|
||||
networkDelivery = NetworkDelivery.Unreliable;
|
||||
break;
|
||||
}
|
||||
|
||||
if (rpcParams.Send.Target == null)
|
||||
{
|
||||
switch (defaultTarget)
|
||||
{
|
||||
case SendTo.Everyone:
|
||||
rpcParams.Send.Target = RpcTarget.Everyone;
|
||||
break;
|
||||
case SendTo.Owner:
|
||||
rpcParams.Send.Target = RpcTarget.Owner;
|
||||
break;
|
||||
case SendTo.Server:
|
||||
rpcParams.Send.Target = RpcTarget.Server;
|
||||
break;
|
||||
case SendTo.NotServer:
|
||||
rpcParams.Send.Target = RpcTarget.NotServer;
|
||||
break;
|
||||
case SendTo.NotMe:
|
||||
rpcParams.Send.Target = RpcTarget.NotMe;
|
||||
break;
|
||||
case SendTo.NotOwner:
|
||||
rpcParams.Send.Target = RpcTarget.NotOwner;
|
||||
break;
|
||||
case SendTo.Me:
|
||||
rpcParams.Send.Target = RpcTarget.Me;
|
||||
break;
|
||||
case SendTo.ClientsAndHost:
|
||||
rpcParams.Send.Target = RpcTarget.ClientsAndHost;
|
||||
break;
|
||||
case SendTo.SpecifiedInParams:
|
||||
throw new RpcException("This method requires a runtime-specified send target.");
|
||||
}
|
||||
}
|
||||
else if (defaultTarget != SendTo.SpecifiedInParams && !attributeParams.AllowTargetOverride)
|
||||
{
|
||||
throw new RpcException("Target override is not allowed for this method.");
|
||||
}
|
||||
|
||||
if (rpcParams.Send.LocalDeferMode == LocalDeferMode.Default)
|
||||
{
|
||||
rpcParams.Send.LocalDeferMode = attributeParams.DeferLocal ? LocalDeferMode.Defer : LocalDeferMode.SendImmediate;
|
||||
}
|
||||
|
||||
rpcParams.Send.Target.Send(this, ref rpcMessage, networkDelivery, rpcParams);
|
||||
|
||||
bufferWriter.Dispose();
|
||||
}
|
||||
|
||||
#pragma warning disable IDE1006 // disable naming rule violation check
|
||||
// RuntimeAccessModifiersILPP will make this `protected`
|
||||
internal static NativeList<T> __createNativeList<T>() where T : unmanaged
|
||||
@@ -315,6 +422,24 @@ namespace Unity.Netcode
|
||||
}
|
||||
}
|
||||
|
||||
// This erroneously tries to simplify these method references but the docs do not pick it up correctly
|
||||
// because they try to resolve it on the field rather than the class of the same name.
|
||||
#pragma warning disable IDE0001
|
||||
/// <summary>
|
||||
/// Provides access to the various <see cref="SendTo"/> targets at runtime, as well as
|
||||
/// runtime-bound targets like <see cref="Unity.Netcode.RpcTarget.Single"/>,
|
||||
/// <see cref="Unity.Netcode.RpcTarget.Group(NativeArray{ulong})"/>,
|
||||
/// <see cref="Unity.Netcode.RpcTarget.Group(NativeList{ulong})"/>,
|
||||
/// <see cref="Unity.Netcode.RpcTarget.Group(ulong[])"/>,
|
||||
/// <see cref="Unity.Netcode.RpcTarget.Group{T}(T)"/>, <see cref="Unity.Netcode.RpcTarget.Not(ulong)"/>,
|
||||
/// <see cref="Unity.Netcode.RpcTarget.Not(NativeArray{ulong})"/>,
|
||||
/// <see cref="Unity.Netcode.RpcTarget.Not(NativeList{ulong})"/>,
|
||||
/// <see cref="Unity.Netcode.RpcTarget.Not(ulong[])"/>, and
|
||||
/// <see cref="Unity.Netcode.RpcTarget.Not{T}(T)"/>
|
||||
/// </summary>
|
||||
#pragma warning restore IDE0001
|
||||
public RpcTarget RpcTarget => NetworkManager.RpcTarget;
|
||||
|
||||
/// <summary>
|
||||
/// If a NetworkObject is assigned, it will return whether or not this NetworkObject
|
||||
/// is the local player object. If no NetworkObject is assigned it will always return false.
|
||||
@@ -331,6 +456,11 @@ namespace Unity.Netcode
|
||||
/// </summary>
|
||||
public bool IsServer { get; private set; }
|
||||
|
||||
/// <summary>
|
||||
/// Gets if the server (local or remote) is a host - i.e., also a client
|
||||
/// </summary>
|
||||
public bool ServerIsHost { get; private set; }
|
||||
|
||||
/// <summary>
|
||||
/// Gets if we are executing as client
|
||||
/// </summary>
|
||||
@@ -375,12 +505,14 @@ namespace Unity.Netcode
|
||||
{
|
||||
get
|
||||
{
|
||||
if (m_NetworkObject != null)
|
||||
{
|
||||
return m_NetworkObject;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
if (m_NetworkObject == null)
|
||||
{
|
||||
m_NetworkObject = GetComponentInParent<NetworkObject>();
|
||||
}
|
||||
m_NetworkObject = GetComponentInParent<NetworkObject>();
|
||||
}
|
||||
catch (Exception)
|
||||
{
|
||||
@@ -472,12 +604,13 @@ namespace Unity.Netcode
|
||||
IsHost = NetworkManager.IsListening && NetworkManager.IsHost;
|
||||
IsClient = NetworkManager.IsListening && NetworkManager.IsClient;
|
||||
IsServer = NetworkManager.IsListening && NetworkManager.IsServer;
|
||||
ServerIsHost = NetworkManager.IsListening && NetworkManager.ServerIsHost;
|
||||
}
|
||||
}
|
||||
else // Shouldn't happen, but if so then set the properties to their default value;
|
||||
{
|
||||
OwnerClientId = NetworkObjectId = default;
|
||||
IsOwnedByServer = IsOwner = IsHost = IsClient = IsServer = default;
|
||||
IsOwnedByServer = IsOwner = IsHost = IsClient = IsServer = ServerIsHost = default;
|
||||
NetworkBehaviourId = default;
|
||||
}
|
||||
}
|
||||
@@ -682,7 +815,16 @@ namespace Unity.Netcode
|
||||
// during OnNetworkSpawn has been sent and needs to be cleared
|
||||
for (int i = 0; i < NetworkVariableFields.Count; i++)
|
||||
{
|
||||
NetworkVariableFields[i].ResetDirty();
|
||||
var networkVariable = NetworkVariableFields[i];
|
||||
if (networkVariable.IsDirty())
|
||||
{
|
||||
if (networkVariable.CanSend())
|
||||
{
|
||||
networkVariable.UpdateLastSentTime();
|
||||
networkVariable.ResetDirty();
|
||||
networkVariable.SetDirty(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
@@ -690,11 +832,18 @@ namespace Unity.Netcode
|
||||
// mark any variables we wrote as no longer dirty
|
||||
for (int i = 0; i < NetworkVariableIndexesToReset.Count; i++)
|
||||
{
|
||||
NetworkVariableFields[NetworkVariableIndexesToReset[i]].ResetDirty();
|
||||
var networkVariable = NetworkVariableFields[NetworkVariableIndexesToReset[i]];
|
||||
if (networkVariable.IsDirty())
|
||||
{
|
||||
if (networkVariable.CanSend())
|
||||
{
|
||||
networkVariable.UpdateLastSentTime();
|
||||
networkVariable.ResetDirty();
|
||||
networkVariable.SetDirty(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
MarkVariablesDirty(false);
|
||||
}
|
||||
|
||||
internal void PreVariableUpdate()
|
||||
@@ -703,7 +852,6 @@ namespace Unity.Netcode
|
||||
{
|
||||
InitializeVariables();
|
||||
}
|
||||
|
||||
PreNetworkVariableWrite();
|
||||
}
|
||||
|
||||
@@ -730,7 +878,10 @@ namespace Unity.Netcode
|
||||
var networkVariable = NetworkVariableFields[k];
|
||||
if (networkVariable.IsDirty() && networkVariable.CanClientRead(targetClientId))
|
||||
{
|
||||
shouldSend = true;
|
||||
if (networkVariable.CanSend())
|
||||
{
|
||||
shouldSend = true;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -771,9 +922,16 @@ namespace Unity.Netcode
|
||||
// TODO: There should be a better way by reading one dirty variable vs. 'n'
|
||||
for (int i = 0; i < NetworkVariableFields.Count; i++)
|
||||
{
|
||||
if (NetworkVariableFields[i].IsDirty())
|
||||
var networkVariable = NetworkVariableFields[i];
|
||||
if (networkVariable.IsDirty())
|
||||
{
|
||||
return true;
|
||||
if (networkVariable.CanSend())
|
||||
{
|
||||
return true;
|
||||
}
|
||||
// If it's dirty but can't be sent yet, we have to keep monitoring it until one of the
|
||||
// conditions blocking its send changes.
|
||||
NetworkManager.BehaviourUpdater.AddForUpdate(NetworkObject);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -930,6 +1088,11 @@ namespace Unity.Netcode
|
||||
|
||||
}
|
||||
|
||||
public virtual void OnReanticipate(double lastRoundTripTime)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The relative client identifier targeted for the serialization of this <see cref="NetworkBehaviour"/> instance.
|
||||
/// </summary>
|
||||
|
||||
@@ -11,6 +11,7 @@ namespace Unity.Netcode
|
||||
private NetworkManager m_NetworkManager;
|
||||
private NetworkConnectionManager m_ConnectionManager;
|
||||
private HashSet<NetworkObject> m_DirtyNetworkObjects = new HashSet<NetworkObject>();
|
||||
private HashSet<NetworkObject> m_PendingDirtyNetworkObjects = new HashSet<NetworkObject>();
|
||||
|
||||
#if DEVELOPMENT_BUILD || UNITY_EDITOR
|
||||
private ProfilerMarker m_NetworkBehaviourUpdate = new ProfilerMarker($"{nameof(NetworkBehaviour)}.{nameof(NetworkBehaviourUpdate)}");
|
||||
@@ -18,7 +19,7 @@ namespace Unity.Netcode
|
||||
|
||||
internal void AddForUpdate(NetworkObject networkObject)
|
||||
{
|
||||
m_DirtyNetworkObjects.Add(networkObject);
|
||||
m_PendingDirtyNetworkObjects.Add(networkObject);
|
||||
}
|
||||
|
||||
internal void NetworkBehaviourUpdate()
|
||||
@@ -28,6 +29,9 @@ namespace Unity.Netcode
|
||||
#endif
|
||||
try
|
||||
{
|
||||
m_DirtyNetworkObjects.UnionWith(m_PendingDirtyNetworkObjects);
|
||||
m_PendingDirtyNetworkObjects.Clear();
|
||||
|
||||
// NetworkObject references can become null, when hidden or despawned. Once NUll, there is no point
|
||||
// trying to process them, even if they were previously marked as dirty.
|
||||
m_DirtyNetworkObjects.RemoveWhere((sobj) => sobj == null);
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using Unity.Collections;
|
||||
using UnityEngine;
|
||||
#if UNITY_EDITOR
|
||||
using UnityEditor;
|
||||
@@ -42,15 +43,27 @@ namespace Unity.Netcode
|
||||
ConnectionManager.ProcessPendingApprovals();
|
||||
ConnectionManager.PollAndHandleNetworkEvents();
|
||||
|
||||
DeferredMessageManager.ProcessTriggers(IDeferredNetworkMessageManager.TriggerType.OnNextFrame, 0);
|
||||
|
||||
AnticipationSystem.SetupForUpdate();
|
||||
MessageManager.ProcessIncomingMessageQueue();
|
||||
MessageManager.CleanupDisconnectedClients();
|
||||
|
||||
AnticipationSystem.ProcessReanticipation();
|
||||
}
|
||||
break;
|
||||
case NetworkUpdateStage.PreUpdate:
|
||||
{
|
||||
NetworkTimeSystem.UpdateTime();
|
||||
AnticipationSystem.Update();
|
||||
}
|
||||
break;
|
||||
case NetworkUpdateStage.PostScriptLateUpdate:
|
||||
|
||||
AnticipationSystem.Sync();
|
||||
AnticipationSystem.SetupForRender();
|
||||
break;
|
||||
|
||||
case NetworkUpdateStage.PostLateUpdate:
|
||||
{
|
||||
// This should be invoked just prior to the MessageManager processes its outbound queue.
|
||||
@@ -70,13 +83,89 @@ namespace Unity.Netcode
|
||||
|
||||
if (m_ShuttingDown)
|
||||
{
|
||||
ShutdownInternal();
|
||||
// Host-server will disconnect any connected clients prior to finalizing its shutdown
|
||||
if (IsServer)
|
||||
{
|
||||
ProcessServerShutdown();
|
||||
}
|
||||
else
|
||||
{
|
||||
// Clients just disconnect immediately
|
||||
ShutdownInternal();
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Used to provide a graceful shutdown sequence
|
||||
/// </summary>
|
||||
internal enum ServerShutdownStates
|
||||
{
|
||||
None,
|
||||
WaitForClientDisconnects,
|
||||
InternalShutdown,
|
||||
ShuttingDown,
|
||||
};
|
||||
|
||||
internal ServerShutdownStates ServerShutdownState;
|
||||
private float m_ShutdownTimeout;
|
||||
|
||||
/// <summary>
|
||||
/// This is a "soft shutdown" where the host or server will disconnect
|
||||
/// all clients, with a provided reasons, prior to invoking its final
|
||||
/// internal shutdown.
|
||||
/// </summary>
|
||||
internal void ProcessServerShutdown()
|
||||
{
|
||||
var minClientCount = IsHost ? 2 : 1;
|
||||
switch (ServerShutdownState)
|
||||
{
|
||||
case ServerShutdownStates.None:
|
||||
{
|
||||
if (ConnectedClients.Count >= minClientCount)
|
||||
{
|
||||
var hostServer = IsHost ? "host" : "server";
|
||||
var disconnectReason = $"Disconnected due to {hostServer} shutting down.";
|
||||
for (int i = ConnectedClientsIds.Count - 1; i >= 0; i--)
|
||||
{
|
||||
var clientId = ConnectedClientsIds[i];
|
||||
if (clientId == ServerClientId)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
ConnectionManager.DisconnectClient(clientId, disconnectReason);
|
||||
}
|
||||
ServerShutdownState = ServerShutdownStates.WaitForClientDisconnects;
|
||||
m_ShutdownTimeout = Time.realtimeSinceStartup + 5.0f;
|
||||
}
|
||||
else
|
||||
{
|
||||
ServerShutdownState = ServerShutdownStates.InternalShutdown;
|
||||
ProcessServerShutdown();
|
||||
}
|
||||
break;
|
||||
}
|
||||
case ServerShutdownStates.WaitForClientDisconnects:
|
||||
{
|
||||
if (ConnectedClients.Count < minClientCount || m_ShutdownTimeout < Time.realtimeSinceStartup)
|
||||
{
|
||||
ServerShutdownState = ServerShutdownStates.InternalShutdown;
|
||||
ProcessServerShutdown();
|
||||
}
|
||||
break;
|
||||
}
|
||||
case ServerShutdownStates.InternalShutdown:
|
||||
{
|
||||
ServerShutdownState = ServerShutdownStates.ShuttingDown;
|
||||
ShutdownInternal();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The client id used to represent the server
|
||||
/// </summary>
|
||||
@@ -104,7 +193,7 @@ namespace Unity.Netcode
|
||||
/// <summary>
|
||||
/// Gets a list of just the IDs of all connected clients. This is only accessible on the server.
|
||||
/// </summary>
|
||||
public IReadOnlyList<ulong> ConnectedClientsIds => IsServer ? ConnectionManager.ConnectedClientIds : throw new NotServerException($"{nameof(ConnectionManager.ConnectedClientIds)} should only be accessed on server.");
|
||||
public IReadOnlyList<ulong> ConnectedClientsIds => ConnectionManager.ConnectedClientIds;
|
||||
|
||||
/// <summary>
|
||||
/// Gets the local <see cref="NetworkClient"/> for this client.
|
||||
@@ -122,6 +211,11 @@ namespace Unity.Netcode
|
||||
/// </summary>
|
||||
public bool IsServer => ConnectionManager.LocalClient.IsServer;
|
||||
|
||||
/// <summary>
|
||||
/// Gets whether or not the current server (local or remote) is a host - i.e., also a client
|
||||
/// </summary>
|
||||
public bool ServerIsHost => ConnectionManager.ConnectedClientIds.Contains(ServerClientId);
|
||||
|
||||
/// <summary>
|
||||
/// Gets Whether or not a client is running
|
||||
/// </summary>
|
||||
@@ -190,6 +284,25 @@ namespace Unity.Netcode
|
||||
remove => ConnectionManager.OnTransportFailure -= value;
|
||||
}
|
||||
|
||||
public delegate void ReanticipateDelegate(double lastRoundTripTime);
|
||||
|
||||
/// <summary>
|
||||
/// This callback is called after all individual OnReanticipate calls on AnticipatedNetworkVariable
|
||||
/// and AnticipatedNetworkTransform values have been invoked. The first parameter is a hash set of
|
||||
/// all the variables that have been changed on this frame (you can detect a particular variable by
|
||||
/// checking if the set contains it), while the second parameter is a set of all anticipated network
|
||||
/// transforms that have been changed. Both are passed as their base class type.
|
||||
///
|
||||
/// The third parameter is the local time corresponding to the current authoritative server state
|
||||
/// (i.e., to determine the amount of time that needs to be re-simulated, you will use
|
||||
/// NetworkManager.LocalTime.Time - authorityTime).
|
||||
/// </summary>
|
||||
public event ReanticipateDelegate OnReanticipate
|
||||
{
|
||||
add => AnticipationSystem.OnReanticipate += value;
|
||||
remove => AnticipationSystem.OnReanticipate -= value;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The callback to invoke during connection approval. Allows client code to decide whether or not to allow incoming client connection
|
||||
/// </summary>
|
||||
@@ -209,6 +322,8 @@ namespace Unity.Netcode
|
||||
|
||||
/// <summary>
|
||||
/// The callback to invoke once a client connects. This callback is only ran on the server and on the local client that connects.
|
||||
///
|
||||
/// It is recommended to use OnConnectionEvent instead, as this will eventually be deprecated
|
||||
/// </summary>
|
||||
public event Action<ulong> OnClientConnectedCallback
|
||||
{
|
||||
@@ -218,6 +333,8 @@ namespace Unity.Netcode
|
||||
|
||||
/// <summary>
|
||||
/// The callback to invoke when a client disconnects. This callback is only ran on the server and on the local client that disconnects.
|
||||
///
|
||||
/// It is recommended to use OnConnectionEvent instead, as this will eventually be deprecated
|
||||
/// </summary>
|
||||
public event Action<ulong> OnClientDisconnectCallback
|
||||
{
|
||||
@@ -225,6 +342,16 @@ namespace Unity.Netcode
|
||||
remove => ConnectionManager.OnClientDisconnectCallback -= value;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The callback to invoke on any connection event. See <see cref="ConnectionEvent"/> and <see cref="ConnectionEventData"/>
|
||||
/// for more info.
|
||||
/// </summary>
|
||||
public event Action<NetworkManager, ConnectionEventData> OnConnectionEvent
|
||||
{
|
||||
add => ConnectionManager.OnConnectionEvent += value;
|
||||
remove => ConnectionManager.OnConnectionEvent -= value;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The current host name we are connected to, used to validate certificate
|
||||
/// </summary>
|
||||
@@ -379,6 +506,24 @@ namespace Unity.Netcode
|
||||
|
||||
internal IDeferredNetworkMessageManager DeferredMessageManager { get; private set; }
|
||||
|
||||
// This erroneously tries to simplify these method references but the docs do not pick it up correctly
|
||||
// because they try to resolve it on the field rather than the class of the same name.
|
||||
#pragma warning disable IDE0001
|
||||
/// <summary>
|
||||
/// Provides access to the various <see cref="SendTo"/> targets at runtime, as well as
|
||||
/// runtime-bound targets like <see cref="Unity.Netcode.RpcTarget.Single"/>,
|
||||
/// <see cref="Unity.Netcode.RpcTarget.Group(NativeArray{ulong})"/>,
|
||||
/// <see cref="Unity.Netcode.RpcTarget.Group(NativeList{ulong})"/>,
|
||||
/// <see cref="Unity.Netcode.RpcTarget.Group(ulong[])"/>,
|
||||
/// <see cref="Unity.Netcode.RpcTarget.Group{T}(T)"/>, <see cref="Unity.Netcode.RpcTarget.Not(ulong)"/>,
|
||||
/// <see cref="Unity.Netcode.RpcTarget.Not(NativeArray{ulong})"/>,
|
||||
/// <see cref="Unity.Netcode.RpcTarget.Not(NativeList{ulong})"/>,
|
||||
/// <see cref="Unity.Netcode.RpcTarget.Not(ulong[])"/>, and
|
||||
/// <see cref="Unity.Netcode.RpcTarget.Not{T}(T)"/>
|
||||
/// </summary>
|
||||
#pragma warning restore IDE0001
|
||||
public RpcTarget RpcTarget;
|
||||
|
||||
/// <summary>
|
||||
/// Gets the CustomMessagingManager for this NetworkManager
|
||||
/// </summary>
|
||||
@@ -402,6 +547,8 @@ namespace Unity.Netcode
|
||||
/// </summary>
|
||||
public NetworkTickSystem NetworkTickSystem { get; private set; }
|
||||
|
||||
internal AnticipationSystem AnticipationSystem { get; private set; }
|
||||
|
||||
/// <summary>
|
||||
/// Used for time mocking in tests
|
||||
/// </summary>
|
||||
@@ -664,6 +811,12 @@ namespace Unity.Netcode
|
||||
|
||||
internal void Initialize(bool server)
|
||||
{
|
||||
// Make sure the ServerShutdownState is reset when initializing
|
||||
if (server)
|
||||
{
|
||||
ServerShutdownState = ServerShutdownStates.None;
|
||||
}
|
||||
|
||||
// Don't allow the user to start a network session if the NetworkManager is
|
||||
// still parented under another GameObject
|
||||
if (NetworkManagerCheckForParent(true))
|
||||
@@ -691,6 +844,7 @@ namespace Unity.Netcode
|
||||
|
||||
this.RegisterNetworkUpdate(NetworkUpdateStage.EarlyUpdate);
|
||||
this.RegisterNetworkUpdate(NetworkUpdateStage.PreUpdate);
|
||||
this.RegisterNetworkUpdate(NetworkUpdateStage.PostScriptLateUpdate);
|
||||
this.RegisterNetworkUpdate(NetworkUpdateStage.PostLateUpdate);
|
||||
|
||||
// ComponentFactory needs to set its defaults next
|
||||
@@ -723,12 +877,15 @@ namespace Unity.Netcode
|
||||
// The remaining systems can then be initialized
|
||||
NetworkTimeSystem = server ? NetworkTimeSystem.ServerTimeSystem() : new NetworkTimeSystem(1.0 / NetworkConfig.TickRate);
|
||||
NetworkTickSystem = NetworkTimeSystem.Initialize(this);
|
||||
AnticipationSystem = new AnticipationSystem(this);
|
||||
|
||||
// Create spawn manager instance
|
||||
SpawnManager = new NetworkSpawnManager(this);
|
||||
|
||||
DeferredMessageManager = ComponentFactory.Create<IDeferredNetworkMessageManager>(this);
|
||||
|
||||
RpcTarget = new RpcTarget(this);
|
||||
|
||||
CustomMessagingManager = new CustomMessagingManager(this);
|
||||
|
||||
SceneManager = new NetworkSceneManager(this);
|
||||
@@ -929,6 +1086,7 @@ namespace Unity.Netcode
|
||||
{
|
||||
LocalClientId = ServerClientId;
|
||||
NetworkMetrics.SetConnectionId(LocalClientId);
|
||||
MessageManager.SetLocalClientId(LocalClientId);
|
||||
|
||||
if (NetworkConfig.ConnectionApproval && ConnectionApprovalCallback != null)
|
||||
{
|
||||
@@ -1007,11 +1165,6 @@ namespace Unity.Netcode
|
||||
MessageManager.StopProcessing = discardMessageQueue;
|
||||
}
|
||||
}
|
||||
|
||||
if (NetworkConfig != null && NetworkConfig.NetworkTransport != null)
|
||||
{
|
||||
NetworkConfig.NetworkTransport.OnTransportEvent -= ConnectionManager.HandleNetworkEvent;
|
||||
}
|
||||
}
|
||||
|
||||
// Ensures that the NetworkManager is cleaned up before OnDestroy is run on NetworkObjects and NetworkBehaviours when unloading a scene with a NetworkManager
|
||||
@@ -1036,6 +1189,9 @@ namespace Unity.Netcode
|
||||
DeferredMessageManager?.CleanupAllTriggers();
|
||||
CustomMessagingManager = null;
|
||||
|
||||
RpcTarget?.Dispose();
|
||||
RpcTarget = null;
|
||||
|
||||
BehaviourUpdater?.Shutdown();
|
||||
BehaviourUpdater = null;
|
||||
|
||||
@@ -1062,6 +1218,12 @@ namespace Unity.Netcode
|
||||
IsListening = false;
|
||||
m_ShuttingDown = false;
|
||||
|
||||
// Generate a local notification that the host client is disconnected
|
||||
if (IsHost)
|
||||
{
|
||||
ConnectionManager.InvokeOnClientDisconnectCallback(LocalClientId);
|
||||
}
|
||||
|
||||
if (ConnectionManager.LocalClient.IsClient)
|
||||
{
|
||||
// If we were a client, we want to know if we were a host
|
||||
|
||||
@@ -26,6 +26,22 @@ namespace Unity.Netcode
|
||||
[SerializeField]
|
||||
internal uint GlobalObjectIdHash;
|
||||
|
||||
/// <summary>
|
||||
/// Used to track the source GlobalObjectIdHash value of the associated network prefab.
|
||||
/// When an override exists or it is in-scene placed, GlobalObjectIdHash and PrefabGlobalObjectIdHash
|
||||
/// will be different. The PrefabGlobalObjectIdHash value is what is used when sending a <see cref="CreateObjectMessage"/>.
|
||||
/// </summary>
|
||||
internal uint PrefabGlobalObjectIdHash;
|
||||
|
||||
/// <summary>
|
||||
/// This is the source prefab of an in-scene placed NetworkObject. This is not set for in-scene
|
||||
/// placd NetworkObjects that are not prefab instances, dynamically spawned prefab instances,
|
||||
/// or for network prefab assets.
|
||||
/// </summary>
|
||||
[HideInInspector]
|
||||
[SerializeField]
|
||||
internal uint InScenePlacedSourceGlobalObjectIdHash;
|
||||
|
||||
/// <summary>
|
||||
/// Gets the Prefab Hash Id of this object if the object is registerd as a prefab otherwise it returns 0
|
||||
/// </summary>
|
||||
@@ -34,15 +50,7 @@ namespace Unity.Netcode
|
||||
{
|
||||
get
|
||||
{
|
||||
foreach (var prefab in NetworkManager.NetworkConfig.Prefabs.Prefabs)
|
||||
{
|
||||
if (prefab.Prefab == gameObject)
|
||||
{
|
||||
return GlobalObjectIdHash;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
return GlobalObjectIdHash;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -149,6 +157,9 @@ namespace Unity.Netcode
|
||||
EditorUtility.SetDirty(this);
|
||||
}
|
||||
}
|
||||
|
||||
// Always check for in-scene placed to assure any previous version scene assets with in-scene place NetworkObjects gets updated
|
||||
CheckForInScenePlaced();
|
||||
}
|
||||
|
||||
private bool IsEditingPrefab()
|
||||
@@ -164,6 +175,33 @@ namespace Unity.Netcode
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// This checks to see if this NetworkObject is an in-scene placed prefab instance. If so it will
|
||||
/// automatically find the source prefab asset's GlobalObjectIdHash value, assign it to
|
||||
/// InScenePlacedSourceGlobalObjectIdHash and mark this as being in-scene placed.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// This NetworkObject is considered an in-scene placed prefab asset instance if it is:
|
||||
/// - Part of a prefab
|
||||
/// - Not being directly edited
|
||||
/// - Within a valid scene that is part of the scenes in build list
|
||||
/// (In-scene defined NetworkObjects that are not part of a prefab instance are excluded.)
|
||||
/// </remarks>
|
||||
private void CheckForInScenePlaced()
|
||||
{
|
||||
if (PrefabUtility.IsPartOfAnyPrefab(this) && !IsEditingPrefab() && gameObject.scene.IsValid() && gameObject.scene.isLoaded && gameObject.scene.buildIndex >= 0)
|
||||
{
|
||||
var prefab = PrefabUtility.GetCorrespondingObjectFromSource(gameObject);
|
||||
var assetPath = AssetDatabase.GetAssetPath(prefab);
|
||||
var sourceAsset = AssetDatabase.LoadAssetAtPath<NetworkObject>(assetPath);
|
||||
if (sourceAsset != null && sourceAsset.GlobalObjectIdHash != 0 && InScenePlacedSourceGlobalObjectIdHash != sourceAsset.GlobalObjectIdHash)
|
||||
{
|
||||
InScenePlacedSourceGlobalObjectIdHash = sourceAsset.GlobalObjectIdHash;
|
||||
}
|
||||
IsSceneObject = true;
|
||||
}
|
||||
}
|
||||
|
||||
private GlobalObjectId GetGlobalId()
|
||||
{
|
||||
var instanceGlobalId = GlobalObjectId.GetGlobalObjectIdSlow(this);
|
||||
@@ -703,7 +741,7 @@ namespace Unity.Netcode
|
||||
// Since we still have a session connection, log locally and on the server to inform user of this issue.
|
||||
if (NetworkManager.LogLevel <= LogLevel.Error)
|
||||
{
|
||||
NetworkLog.LogErrorServer($"Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call {nameof(Destroy)} or {nameof(Despawn)} on the server/host instead.");
|
||||
NetworkLog.LogErrorServer($"[Invalid Destroy][{gameObject.name}][NetworkObjectId:{NetworkObjectId}] Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call {nameof(Destroy)} or {nameof(Despawn)} on the server/host instead.");
|
||||
}
|
||||
return;
|
||||
}
|
||||
@@ -720,7 +758,7 @@ namespace Unity.Netcode
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
private void SpawnInternal(bool destroyWithScene, ulong ownerClientId, bool playerObject)
|
||||
internal void SpawnInternal(bool destroyWithScene, ulong ownerClientId, bool playerObject)
|
||||
{
|
||||
if (!NetworkManager.IsListening)
|
||||
{
|
||||
@@ -743,6 +781,78 @@ namespace Unity.Netcode
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// This invokes <see cref="NetworkSpawnManager.InstantiateAndSpawn(NetworkObject, ulong, bool, bool, bool, Vector3, Quaternion)"/>.
|
||||
/// </summary>
|
||||
/// <param name="networkPrefab">The NetworkPrefab to instantiate and spawn.</param>
|
||||
/// <param name="networkManager">The local instance of the NetworkManager connected to an session in progress.</param>
|
||||
/// <param name="ownerClientId">The owner of the <see cref="NetworkObject"/> instance (defaults to server).</param>
|
||||
/// <param name="destroyWithScene">Whether the <see cref="NetworkObject"/> instance will be destroyed when the scene it is located within is unloaded (default is false).</param>
|
||||
/// <param name="isPlayerObject">Whether the <see cref="NetworkObject"/> instance is a player object or not (default is false).</param>
|
||||
/// <param name="forceOverride">Whether you want to force spawning the override when running as a host or server or if you want it to spawn the override for host mode and
|
||||
/// the source prefab for server. If there is an override, clients always spawn that as opposed to the source prefab (defaults to false). </param>
|
||||
/// <param name="position">The starting poisiton of the <see cref="NetworkObject"/> instance.</param>
|
||||
/// <param name="rotation">The starting rotation of the <see cref="NetworkObject"/> instance.</param>
|
||||
/// <returns>The newly instantiated and spawned <see cref="NetworkObject"/> prefab instance.</returns>
|
||||
public static NetworkObject InstantiateAndSpawn(GameObject networkPrefab, NetworkManager networkManager, ulong ownerClientId = NetworkManager.ServerClientId, bool destroyWithScene = false, bool isPlayerObject = false, bool forceOverride = false, Vector3 position = default, Quaternion rotation = default)
|
||||
{
|
||||
var networkObject = networkPrefab.GetComponent<NetworkObject>();
|
||||
if (networkObject == null)
|
||||
{
|
||||
Debug.LogError($"The {nameof(NetworkPrefab)} {networkPrefab.name} does not have a {nameof(NetworkObject)} component!");
|
||||
return null;
|
||||
}
|
||||
return networkObject.InstantiateAndSpawn(networkManager, ownerClientId, destroyWithScene, isPlayerObject, forceOverride, position, rotation);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// This invokes <see cref="NetworkSpawnManager.InstantiateAndSpawn(NetworkObject, ulong, bool, bool, bool, Vector3, Quaternion)"/>.
|
||||
/// </summary>
|
||||
/// <param name="networkManager">The local instance of the NetworkManager connected to an session in progress.</param>
|
||||
/// <param name="ownerClientId">The owner of the <see cref="NetworkObject"/> instance (defaults to server).</param>
|
||||
/// <param name="destroyWithScene">Whether the <see cref="NetworkObject"/> instance will be destroyed when the scene it is located within is unloaded (default is false).</param>
|
||||
/// <param name="isPlayerObject">Whether the <see cref="NetworkObject"/> instance is a player object or not (default is false).</param>
|
||||
/// <param name="forceOverride">Whether you want to force spawning the override when running as a host or server or if you want it to spawn the override for host mode and
|
||||
/// the source prefab for server. If there is an override, clients always spawn that as opposed to the source prefab (defaults to false). </param>
|
||||
/// <param name="position">The starting poisiton of the <see cref="NetworkObject"/> instance.</param>
|
||||
/// <param name="rotation">The starting rotation of the <see cref="NetworkObject"/> instance.</param>
|
||||
/// <returns>The newly instantiated and spawned <see cref="NetworkObject"/> prefab instance.</returns>
|
||||
public NetworkObject InstantiateAndSpawn(NetworkManager networkManager, ulong ownerClientId = NetworkManager.ServerClientId, bool destroyWithScene = false, bool isPlayerObject = false, bool forceOverride = false, Vector3 position = default, Quaternion rotation = default)
|
||||
{
|
||||
if (networkManager == null)
|
||||
{
|
||||
Debug.LogError(NetworkSpawnManager.InstantiateAndSpawnErrors[NetworkSpawnManager.InstantiateAndSpawnErrorTypes.NetworkManagerNull]);
|
||||
return null;
|
||||
}
|
||||
|
||||
if (!networkManager.IsListening)
|
||||
{
|
||||
Debug.LogError(NetworkSpawnManager.InstantiateAndSpawnErrors[NetworkSpawnManager.InstantiateAndSpawnErrorTypes.NoActiveSession]);
|
||||
return null;
|
||||
}
|
||||
|
||||
if (!networkManager.IsServer)
|
||||
{
|
||||
Debug.LogError(NetworkSpawnManager.InstantiateAndSpawnErrors[NetworkSpawnManager.InstantiateAndSpawnErrorTypes.NotAuthority]);
|
||||
return null;
|
||||
}
|
||||
|
||||
if (NetworkManager.ShutdownInProgress)
|
||||
{
|
||||
Debug.LogWarning(NetworkSpawnManager.InstantiateAndSpawnErrors[NetworkSpawnManager.InstantiateAndSpawnErrorTypes.InvokedWhenShuttingDown]);
|
||||
return null;
|
||||
}
|
||||
|
||||
// Verify it is actually a valid prefab
|
||||
if (!NetworkManager.NetworkConfig.Prefabs.Contains(gameObject))
|
||||
{
|
||||
Debug.LogError(NetworkSpawnManager.InstantiateAndSpawnErrors[NetworkSpawnManager.InstantiateAndSpawnErrorTypes.NotRegisteredNetworkPrefab]);
|
||||
return null;
|
||||
}
|
||||
|
||||
return NetworkManager.SpawnManager.InstantiateAndSpawnNoParameterChecks(this, ownerClientId, destroyWithScene, isPlayerObject, forceOverride, position, rotation);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Spawns this <see cref="NetworkObject"/> across the network. Can only be called from the Server
|
||||
/// </summary>
|
||||
@@ -882,6 +992,11 @@ namespace Unity.Netcode
|
||||
m_CachedParent = parentTransform;
|
||||
}
|
||||
|
||||
internal Transform GetCachedParent()
|
||||
{
|
||||
return m_CachedParent;
|
||||
}
|
||||
|
||||
internal ulong? GetNetworkParenting() => m_LatestParent;
|
||||
|
||||
internal void SetNetworkParenting(ulong? latestParent, bool worldPositionStays)
|
||||
@@ -969,20 +1084,21 @@ namespace Unity.Netcode
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!NetworkManager.IsServer)
|
||||
if (!NetworkManager.IsServer && !NetworkManager.ShutdownInProgress)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!IsSpawned)
|
||||
// If the parent is not null fail only if either of the two is true:
|
||||
// - This instance is spawned and the parent is not.
|
||||
// - This instance is not spawned and the parent is.
|
||||
// Basically, don't allow parenting when either the child or parent is not spawned.
|
||||
// Caveat: if the parent is null then we can allow parenting whether the instance is or is not spawned.
|
||||
if (parent != null && (IsSpawned ^ parent.IsSpawned))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (parent != null && !parent.IsSpawned)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
m_CachedWorldPositionStays = worldPositionStays;
|
||||
|
||||
if (parent == null)
|
||||
@@ -1018,15 +1134,36 @@ namespace Unity.Netcode
|
||||
|
||||
if (!NetworkManager.IsServer)
|
||||
{
|
||||
transform.parent = m_CachedParent;
|
||||
Debug.LogException(new NotServerException($"Only the server can reparent {nameof(NetworkObject)}s"));
|
||||
// Log exception if we are a client and not shutting down.
|
||||
if (!NetworkManager.ShutdownInProgress)
|
||||
{
|
||||
transform.parent = m_CachedParent;
|
||||
Debug.LogException(new NotServerException($"Only the server can reparent {nameof(NetworkObject)}s"));
|
||||
}
|
||||
else // Otherwise, if we are removing a parent then go ahead and allow parenting to occur
|
||||
if (transform.parent == null)
|
||||
{
|
||||
m_LatestParent = null;
|
||||
m_CachedParent = null;
|
||||
InvokeBehaviourOnNetworkObjectParentChanged(null);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
else // Otherwise, on the serer side if this instance is not spawned...
|
||||
if (!IsSpawned)
|
||||
{
|
||||
transform.parent = m_CachedParent;
|
||||
Debug.LogException(new SpawnStateException($"{nameof(NetworkObject)} can only be reparented after being spawned"));
|
||||
// ,,,and we are removing the parent, then go ahead and allow parenting to occur
|
||||
if (transform.parent == null)
|
||||
{
|
||||
m_LatestParent = null;
|
||||
m_CachedParent = null;
|
||||
InvokeBehaviourOnNetworkObjectParentChanged(null);
|
||||
}
|
||||
else
|
||||
{
|
||||
transform.parent = m_CachedParent;
|
||||
Debug.LogException(new SpawnStateException($"{nameof(NetworkObject)} can only be reparented after being spawned"));
|
||||
}
|
||||
return;
|
||||
}
|
||||
var removeParent = false;
|
||||
@@ -1104,7 +1241,7 @@ namespace Unity.Netcode
|
||||
// we call CheckOrphanChildren() method and quickly iterate over OrphanChildren set and see if we can reparent/adopt one.
|
||||
internal static HashSet<NetworkObject> OrphanChildren = new HashSet<NetworkObject>();
|
||||
|
||||
internal bool ApplyNetworkParenting(bool removeParent = false, bool ignoreNotSpawned = false)
|
||||
internal bool ApplyNetworkParenting(bool removeParent = false, bool ignoreNotSpawned = false, bool orphanedChildPass = false)
|
||||
{
|
||||
if (!AutoObjectParentSync)
|
||||
{
|
||||
@@ -1192,9 +1329,17 @@ namespace Unity.Netcode
|
||||
// If we made it here, then parent this instance under the parentObject
|
||||
var parentObject = NetworkManager.SpawnManager.SpawnedObjects[m_LatestParent.Value];
|
||||
|
||||
// If we are handling an orphaned child and its parent is orphaned too, then don't parent yet.
|
||||
if (orphanedChildPass)
|
||||
{
|
||||
if (OrphanChildren.Contains(parentObject))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
m_CachedParent = parentObject.transform;
|
||||
transform.SetParent(parentObject.transform, m_CachedWorldPositionStays);
|
||||
|
||||
InvokeBehaviourOnNetworkObjectParentChanged(parentObject);
|
||||
return true;
|
||||
}
|
||||
@@ -1204,7 +1349,7 @@ namespace Unity.Netcode
|
||||
var objectsToRemove = new List<NetworkObject>();
|
||||
foreach (var orphanObject in OrphanChildren)
|
||||
{
|
||||
if (orphanObject.ApplyNetworkParenting())
|
||||
if (orphanObject.ApplyNetworkParenting(orphanedChildPass: true))
|
||||
{
|
||||
objectsToRemove.Add(orphanObject);
|
||||
}
|
||||
@@ -1665,6 +1810,12 @@ namespace Unity.Netcode
|
||||
var syncRotationPositionLocalSpaceRelative = obj.HasParent && !m_CachedWorldPositionStays;
|
||||
var syncScaleLocalSpaceRelative = obj.HasParent && !m_CachedWorldPositionStays;
|
||||
|
||||
// Always synchronize in-scene placed object's scale using local space
|
||||
if (obj.IsSceneObject)
|
||||
{
|
||||
syncScaleLocalSpaceRelative = obj.HasParent;
|
||||
}
|
||||
|
||||
// If auto object synchronization is turned off
|
||||
if (!AutoObjectParentSync)
|
||||
{
|
||||
@@ -1676,7 +1827,6 @@ namespace Unity.Netcode
|
||||
syncScaleLocalSpaceRelative = obj.HasParent;
|
||||
}
|
||||
|
||||
|
||||
obj.Transform = new SceneObject.TransformData
|
||||
{
|
||||
// If we are parented and we have the m_CachedWorldPositionStays disabled, then use local space
|
||||
@@ -1869,16 +2019,39 @@ namespace Unity.Netcode
|
||||
/// <returns></returns>
|
||||
internal uint HostCheckForGlobalObjectIdHashOverride()
|
||||
{
|
||||
if (NetworkManager.IsHost)
|
||||
if (NetworkManager.IsServer)
|
||||
{
|
||||
if (NetworkManager.PrefabHandler.ContainsHandler(this))
|
||||
{
|
||||
var globalObjectIdHash = NetworkManager.PrefabHandler.GetSourceGlobalObjectIdHash(GlobalObjectIdHash);
|
||||
return globalObjectIdHash == 0 ? GlobalObjectIdHash : globalObjectIdHash;
|
||||
}
|
||||
if (NetworkManager.NetworkConfig.Prefabs.OverrideToNetworkPrefab.TryGetValue(GlobalObjectIdHash, out uint hash))
|
||||
|
||||
// If scene management is disabled and this is an in-scene placed NetworkObject then go ahead
|
||||
// and send the InScenePlacedSourcePrefab's GlobalObjectIdHash value (i.e. what to dynamically spawn)
|
||||
if (!NetworkManager.NetworkConfig.EnableSceneManagement && IsSceneObject.Value && InScenePlacedSourceGlobalObjectIdHash != 0)
|
||||
{
|
||||
return hash;
|
||||
return InScenePlacedSourceGlobalObjectIdHash;
|
||||
}
|
||||
|
||||
// If the PrefabGlobalObjectIdHash is a non-zero value and the GlobalObjectIdHash value is
|
||||
// different from the PrefabGlobalObjectIdHash value, then the NetworkObject instance is
|
||||
// an override for the original network prefab (i.e. PrefabGlobalObjectIdHash)
|
||||
if (!IsSceneObject.Value && GlobalObjectIdHash != PrefabGlobalObjectIdHash)
|
||||
{
|
||||
// If the PrefabGlobalObjectIdHash is already populated (i.e. InstantiateAndSpawn used), then return this
|
||||
if (PrefabGlobalObjectIdHash != 0)
|
||||
{
|
||||
return PrefabGlobalObjectIdHash;
|
||||
}
|
||||
else
|
||||
{
|
||||
// For legacy manual instantiation and spawning, check the OverrideToNetworkPrefab for a possible match
|
||||
if (NetworkManager.NetworkConfig.Prefabs.OverrideToNetworkPrefab.ContainsKey(GlobalObjectIdHash))
|
||||
{
|
||||
return NetworkManager.NetworkConfig.Prefabs.OverrideToNetworkPrefab[GlobalObjectIdHash];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -54,7 +54,14 @@ namespace Unity.Netcode
|
||||
/// </summary>
|
||||
PreLateUpdate = 6,
|
||||
/// <summary>
|
||||
/// Updated after Monobehaviour.LateUpdate, but BEFORE rendering
|
||||
/// </summary>
|
||||
// Yes, these numbers are out of order due to backward compatibility requirements.
|
||||
// The enum values are listed in the order they will be called.
|
||||
PostScriptLateUpdate = 8,
|
||||
/// <summary>
|
||||
/// Updated after the Monobehaviour.LateUpdate for all components is invoked
|
||||
/// and all rendering is complete
|
||||
/// </summary>
|
||||
PostLateUpdate = 7
|
||||
}
|
||||
@@ -258,6 +265,18 @@ namespace Unity.Netcode
|
||||
}
|
||||
}
|
||||
|
||||
internal struct NetworkPostScriptLateUpdate
|
||||
{
|
||||
public static PlayerLoopSystem CreateLoopSystem()
|
||||
{
|
||||
return new PlayerLoopSystem
|
||||
{
|
||||
type = typeof(NetworkPostScriptLateUpdate),
|
||||
updateDelegate = () => RunNetworkUpdateStage(NetworkUpdateStage.PostScriptLateUpdate)
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
internal struct NetworkPostLateUpdate
|
||||
{
|
||||
public static PlayerLoopSystem CreateLoopSystem()
|
||||
@@ -399,6 +418,7 @@ namespace Unity.Netcode
|
||||
else if (currentSystem.type == typeof(PreLateUpdate))
|
||||
{
|
||||
TryAddLoopSystem(ref currentSystem, NetworkPreLateUpdate.CreateLoopSystem(), typeof(PreLateUpdate.ScriptRunBehaviourLateUpdate), LoopSystemPosition.Before);
|
||||
TryAddLoopSystem(ref currentSystem, NetworkPostScriptLateUpdate.CreateLoopSystem(), typeof(PreLateUpdate.ScriptRunBehaviourLateUpdate), LoopSystemPosition.After);
|
||||
}
|
||||
else if (currentSystem.type == typeof(PostLateUpdate))
|
||||
{
|
||||
@@ -440,6 +460,7 @@ namespace Unity.Netcode
|
||||
else if (currentSystem.type == typeof(PreLateUpdate))
|
||||
{
|
||||
TryRemoveLoopSystem(ref currentSystem, typeof(NetworkPreLateUpdate));
|
||||
TryRemoveLoopSystem(ref currentSystem, typeof(NetworkPostScriptLateUpdate));
|
||||
}
|
||||
else if (currentSystem.type == typeof(PostLateUpdate))
|
||||
{
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using Unity.Collections;
|
||||
using UnityEngine;
|
||||
|
||||
namespace Unity.Netcode
|
||||
{
|
||||
@@ -199,6 +200,14 @@ namespace Unity.Netcode
|
||||
/// <param name="callback">The callback to run when a named message is received.</param>
|
||||
public void RegisterNamedMessageHandler(string name, HandleNamedMessageDelegate callback)
|
||||
{
|
||||
if (string.IsNullOrEmpty(name))
|
||||
{
|
||||
if (m_NetworkManager.LogLevel <= LogLevel.Error)
|
||||
{
|
||||
Debug.LogError($"[{nameof(RegisterNamedMessageHandler)}] Cannot register a named message of type null or empty!");
|
||||
}
|
||||
return;
|
||||
}
|
||||
var hash32 = XXHash.Hash32(name);
|
||||
var hash64 = XXHash.Hash64(name);
|
||||
|
||||
@@ -215,6 +224,15 @@ namespace Unity.Netcode
|
||||
/// <param name="name">The name of the message.</param>
|
||||
public void UnregisterNamedMessageHandler(string name)
|
||||
{
|
||||
if (string.IsNullOrEmpty(name))
|
||||
{
|
||||
if (m_NetworkManager.LogLevel <= LogLevel.Error)
|
||||
{
|
||||
Debug.LogError($"[{nameof(UnregisterNamedMessageHandler)}] Cannot unregister a named message of type null or empty!");
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
var hash32 = XXHash.Hash32(name);
|
||||
var hash64 = XXHash.Hash64(name);
|
||||
|
||||
|
||||
@@ -113,6 +113,7 @@ namespace Unity.Netcode
|
||||
// processed before the object is fully spawned. This must be the last thing done in the spawn process.
|
||||
if (triggers.TryGetValue(key, out var triggerInfo))
|
||||
{
|
||||
triggers.Remove(key);
|
||||
foreach (var deferredMessage in triggerInfo.TriggerData)
|
||||
{
|
||||
// Reader will be disposed within HandleMessage
|
||||
@@ -120,7 +121,6 @@ namespace Unity.Netcode
|
||||
}
|
||||
|
||||
triggerInfo.TriggerData.Dispose();
|
||||
triggers.Remove(key);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ namespace Unity.Netcode
|
||||
{
|
||||
OnSpawn,
|
||||
OnAddPrefab,
|
||||
OnNextFrame,
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
||||
70
Runtime/Messaging/Messages/AnticipationCounterSync.cs
Normal file
70
Runtime/Messaging/Messages/AnticipationCounterSync.cs
Normal file
@@ -0,0 +1,70 @@
|
||||
namespace Unity.Netcode
|
||||
{
|
||||
internal struct AnticipationCounterSyncPingMessage : INetworkMessage
|
||||
{
|
||||
public int Version => 0;
|
||||
|
||||
public ulong Counter;
|
||||
public double Time;
|
||||
|
||||
public void Serialize(FastBufferWriter writer, int targetVersion)
|
||||
{
|
||||
BytePacker.WriteValuePacked(writer, Counter);
|
||||
writer.WriteValueSafe(Time);
|
||||
}
|
||||
|
||||
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
|
||||
{
|
||||
var networkManager = (NetworkManager)context.SystemOwner;
|
||||
if (!networkManager.IsServer)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
ByteUnpacker.ReadValuePacked(reader, out Counter);
|
||||
reader.ReadValueSafe(out Time);
|
||||
return true;
|
||||
}
|
||||
|
||||
public void Handle(ref NetworkContext context)
|
||||
{
|
||||
var networkManager = (NetworkManager)context.SystemOwner;
|
||||
if (networkManager.IsListening && !networkManager.ShutdownInProgress && networkManager.ConnectedClients.ContainsKey(context.SenderId))
|
||||
{
|
||||
var message = new AnticipationCounterSyncPongMessage { Counter = Counter, Time = Time };
|
||||
networkManager.MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, context.SenderId);
|
||||
}
|
||||
}
|
||||
}
|
||||
internal struct AnticipationCounterSyncPongMessage : INetworkMessage
|
||||
{
|
||||
public int Version => 0;
|
||||
|
||||
public ulong Counter;
|
||||
public double Time;
|
||||
|
||||
public void Serialize(FastBufferWriter writer, int targetVersion)
|
||||
{
|
||||
BytePacker.WriteValuePacked(writer, Counter);
|
||||
writer.WriteValueSafe(Time);
|
||||
}
|
||||
|
||||
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
|
||||
{
|
||||
var networkManager = (NetworkManager)context.SystemOwner;
|
||||
if (!networkManager.IsClient)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
ByteUnpacker.ReadValuePacked(reader, out Counter);
|
||||
reader.ReadValueSafe(out Time);
|
||||
return true;
|
||||
}
|
||||
|
||||
public void Handle(ref NetworkContext context)
|
||||
{
|
||||
var networkManager = (NetworkManager)context.SystemOwner;
|
||||
networkManager.AnticipationSystem.LastAnticipationAck = Counter;
|
||||
networkManager.AnticipationSystem.LastAnticipationAckTime = Time;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: db5034828a9741ce9bc8ec9a64d5a5b6
|
||||
timeCreated: 1706042908
|
||||
35
Runtime/Messaging/Messages/ClientConnectedMessage.cs
Normal file
35
Runtime/Messaging/Messages/ClientConnectedMessage.cs
Normal file
@@ -0,0 +1,35 @@
|
||||
namespace Unity.Netcode
|
||||
{
|
||||
internal struct ClientConnectedMessage : INetworkMessage, INetworkSerializeByMemcpy
|
||||
{
|
||||
public int Version => 0;
|
||||
|
||||
public ulong ClientId;
|
||||
|
||||
public void Serialize(FastBufferWriter writer, int targetVersion)
|
||||
{
|
||||
BytePacker.WriteValueBitPacked(writer, ClientId);
|
||||
}
|
||||
|
||||
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
|
||||
{
|
||||
var networkManager = (NetworkManager)context.SystemOwner;
|
||||
if (!networkManager.IsClient)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
ByteUnpacker.ReadValueBitPacked(reader, out ClientId);
|
||||
return true;
|
||||
}
|
||||
|
||||
public void Handle(ref NetworkContext context)
|
||||
{
|
||||
var networkManager = (NetworkManager)context.SystemOwner;
|
||||
networkManager.ConnectionManager.ConnectedClientIds.Add(ClientId);
|
||||
if (networkManager.IsConnectedClient)
|
||||
{
|
||||
networkManager.ConnectionManager.InvokeOnPeerConnectedCallback(ClientId);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 158454105806474cba54a4ea5a0bfb12
|
||||
timeCreated: 1697836112
|
||||
35
Runtime/Messaging/Messages/ClientDisconnectedMessage.cs
Normal file
35
Runtime/Messaging/Messages/ClientDisconnectedMessage.cs
Normal file
@@ -0,0 +1,35 @@
|
||||
namespace Unity.Netcode
|
||||
{
|
||||
internal struct ClientDisconnectedMessage : INetworkMessage, INetworkSerializeByMemcpy
|
||||
{
|
||||
public int Version => 0;
|
||||
|
||||
public ulong ClientId;
|
||||
|
||||
public void Serialize(FastBufferWriter writer, int targetVersion)
|
||||
{
|
||||
BytePacker.WriteValueBitPacked(writer, ClientId);
|
||||
}
|
||||
|
||||
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
|
||||
{
|
||||
var networkManager = (NetworkManager)context.SystemOwner;
|
||||
if (!networkManager.IsClient)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
ByteUnpacker.ReadValueBitPacked(reader, out ClientId);
|
||||
return true;
|
||||
}
|
||||
|
||||
public void Handle(ref NetworkContext context)
|
||||
{
|
||||
var networkManager = (NetworkManager)context.SystemOwner;
|
||||
networkManager.ConnectionManager.ConnectedClientIds.Remove(ClientId);
|
||||
if (networkManager.IsConnectedClient)
|
||||
{
|
||||
networkManager.ConnectionManager.InvokeOnPeerDisconnectedCallback(ClientId);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 8f91296c8e5f40b1a2a03d74a31526b6
|
||||
timeCreated: 1697836161
|
||||
@@ -5,7 +5,8 @@ namespace Unity.Netcode
|
||||
{
|
||||
internal struct ConnectionApprovedMessage : INetworkMessage
|
||||
{
|
||||
public int Version => 0;
|
||||
private const int k_VersionAddClientIds = 1;
|
||||
public int Version => k_VersionAddClientIds;
|
||||
|
||||
public ulong OwnerClientId;
|
||||
public int NetworkTick;
|
||||
@@ -17,6 +18,8 @@ namespace Unity.Netcode
|
||||
|
||||
public NativeArray<MessageVersionData> MessageVersions;
|
||||
|
||||
public NativeArray<ulong> ConnectedClientIds;
|
||||
|
||||
public void Serialize(FastBufferWriter writer, int targetVersion)
|
||||
{
|
||||
// ============================================================
|
||||
@@ -36,6 +39,11 @@ namespace Unity.Netcode
|
||||
BytePacker.WriteValueBitPacked(writer, OwnerClientId);
|
||||
BytePacker.WriteValueBitPacked(writer, NetworkTick);
|
||||
|
||||
if (targetVersion >= k_VersionAddClientIds)
|
||||
{
|
||||
writer.WriteValueSafe(ConnectedClientIds);
|
||||
}
|
||||
|
||||
uint sceneObjectCount = 0;
|
||||
|
||||
// When SpawnedObjectsList is not null then scene management is disabled. Provide a list of
|
||||
@@ -106,6 +114,16 @@ namespace Unity.Netcode
|
||||
|
||||
ByteUnpacker.ReadValueBitPacked(reader, out OwnerClientId);
|
||||
ByteUnpacker.ReadValueBitPacked(reader, out NetworkTick);
|
||||
|
||||
if (receivedMessageVersion >= k_VersionAddClientIds)
|
||||
{
|
||||
reader.ReadValueSafe(out ConnectedClientIds, Allocator.TempJob);
|
||||
}
|
||||
else
|
||||
{
|
||||
ConnectedClientIds = new NativeArray<ulong>(0, Allocator.TempJob);
|
||||
}
|
||||
|
||||
m_ReceivedSceneObjectData = reader;
|
||||
return true;
|
||||
}
|
||||
@@ -114,6 +132,7 @@ namespace Unity.Netcode
|
||||
{
|
||||
var networkManager = (NetworkManager)context.SystemOwner;
|
||||
networkManager.LocalClientId = OwnerClientId;
|
||||
networkManager.MessageManager.SetLocalClientId(networkManager.LocalClientId);
|
||||
networkManager.NetworkMetrics.SetConnectionId(networkManager.LocalClientId);
|
||||
|
||||
var time = new NetworkTime(networkManager.NetworkTickSystem.TickRate, NetworkTick);
|
||||
@@ -126,6 +145,12 @@ namespace Unity.Netcode
|
||||
// Stop the client-side approval timeout coroutine since we are approved.
|
||||
networkManager.ConnectionManager.StopClientApprovalCoroutine();
|
||||
|
||||
networkManager.ConnectionManager.ConnectedClientIds.Clear();
|
||||
foreach (var clientId in ConnectedClientIds)
|
||||
{
|
||||
networkManager.ConnectionManager.ConnectedClientIds.Add(clientId);
|
||||
}
|
||||
|
||||
// Only if scene management is disabled do we handle NetworkObject synchronization at this point
|
||||
if (!networkManager.NetworkConfig.EnableSceneManagement)
|
||||
{
|
||||
@@ -146,6 +171,8 @@ namespace Unity.Netcode
|
||||
// When scene management is disabled we notify after everything is synchronized
|
||||
networkManager.ConnectionManager.InvokeOnClientConnectedCallback(context.SenderId);
|
||||
}
|
||||
|
||||
ConnectedClientIds.Dispose();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
using System.Runtime.CompilerServices;
|
||||
namespace Unity.Netcode
|
||||
{
|
||||
internal struct CreateObjectMessage : INetworkMessage
|
||||
@@ -34,9 +35,29 @@ namespace Unity.Netcode
|
||||
public void Handle(ref NetworkContext context)
|
||||
{
|
||||
var networkManager = (NetworkManager)context.SystemOwner;
|
||||
var networkObject = NetworkObject.AddSceneObject(ObjectInfo, m_ReceivedNetworkVariableData, networkManager);
|
||||
// If a client receives a create object message and it is still synchronizing, then defer the object creation until it has finished synchronizing
|
||||
if (networkManager.SceneManager.ShouldDeferCreateObject())
|
||||
{
|
||||
networkManager.SceneManager.DeferCreateObject(context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData);
|
||||
}
|
||||
else
|
||||
{
|
||||
CreateObject(ref networkManager, context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData);
|
||||
}
|
||||
}
|
||||
|
||||
networkManager.NetworkMetrics.TrackObjectSpawnReceived(context.SenderId, networkObject, context.MessageSize);
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
internal static void CreateObject(ref NetworkManager networkManager, ulong senderId, uint messageSize, NetworkObject.SceneObject sceneObject, FastBufferReader networkVariableData)
|
||||
{
|
||||
try
|
||||
{
|
||||
var networkObject = NetworkObject.AddSceneObject(sceneObject, networkVariableData, networkManager);
|
||||
networkManager.NetworkMetrics.TrackObjectSpawnReceived(senderId, networkObject, messageSize);
|
||||
}
|
||||
catch (System.Exception ex)
|
||||
{
|
||||
UnityEngine.Debug.LogException(ex);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -25,9 +25,9 @@ namespace Unity.Netcode
|
||||
public void Handle(ref NetworkContext context)
|
||||
{
|
||||
var networkManager = (NetworkManager)context.SystemOwner;
|
||||
if (!networkManager.ShutdownInProgress)
|
||||
if (!networkManager.ShutdownInProgress && networkManager.CustomMessagingManager != null)
|
||||
{
|
||||
((NetworkManager)context.SystemOwner).CustomMessagingManager.InvokeNamedMessage(Hash, context.SenderId, m_ReceiveData, context.SerializedHeaderSize);
|
||||
networkManager.CustomMessagingManager.InvokeNamedMessage(Hash, context.SenderId, m_ReceiveData, context.SerializedHeaderSize);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -30,6 +30,9 @@ namespace Unity.Netcode
|
||||
throw new OverflowException($"Not enough space in the buffer to write {nameof(NetworkVariableDeltaMessage)}");
|
||||
}
|
||||
|
||||
var obj = NetworkBehaviour.NetworkObject;
|
||||
var networkManager = obj.NetworkManagerOwner;
|
||||
|
||||
BytePacker.WriteValueBitPacked(writer, NetworkObjectId);
|
||||
BytePacker.WriteValueBitPacked(writer, NetworkBehaviourIndex);
|
||||
|
||||
@@ -38,7 +41,7 @@ namespace Unity.Netcode
|
||||
if (!DeliveryMappedNetworkVariableIndex.Contains(i))
|
||||
{
|
||||
// This var does not belong to the currently iterating delivery group.
|
||||
if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
|
||||
if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
|
||||
{
|
||||
BytePacker.WriteValueBitPacked(writer, (ushort)0);
|
||||
}
|
||||
@@ -52,9 +55,11 @@ namespace Unity.Netcode
|
||||
|
||||
var startingSize = writer.Length;
|
||||
var networkVariable = NetworkBehaviour.NetworkVariableFields[i];
|
||||
|
||||
var shouldWrite = networkVariable.IsDirty() &&
|
||||
networkVariable.CanClientRead(TargetClientId) &&
|
||||
(NetworkBehaviour.NetworkManager.IsServer || networkVariable.CanClientWrite(NetworkBehaviour.NetworkManager.LocalClientId));
|
||||
(networkManager.IsServer || networkVariable.CanClientWrite(networkManager.LocalClientId)) &&
|
||||
networkVariable.CanSend();
|
||||
|
||||
// Prevent the server from writing to the client that owns a given NetworkVariable
|
||||
// Allowing the write would send an old value to the client and cause jitter
|
||||
@@ -67,14 +72,14 @@ namespace Unity.Netcode
|
||||
// The object containing the behaviour we're about to process is about to be shown to this client
|
||||
// As a result, the client will get the fully serialized NetworkVariable and would be confused by
|
||||
// an extraneous delta
|
||||
if (NetworkBehaviour.NetworkManager.SpawnManager.ObjectsToShowToClient.ContainsKey(TargetClientId) &&
|
||||
NetworkBehaviour.NetworkManager.SpawnManager.ObjectsToShowToClient[TargetClientId]
|
||||
.Contains(NetworkBehaviour.NetworkObject))
|
||||
if (networkManager.SpawnManager.ObjectsToShowToClient.ContainsKey(TargetClientId) &&
|
||||
networkManager.SpawnManager.ObjectsToShowToClient[TargetClientId]
|
||||
.Contains(obj))
|
||||
{
|
||||
shouldWrite = false;
|
||||
}
|
||||
|
||||
if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
|
||||
if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
|
||||
{
|
||||
if (!shouldWrite)
|
||||
{
|
||||
@@ -88,9 +93,9 @@ namespace Unity.Netcode
|
||||
|
||||
if (shouldWrite)
|
||||
{
|
||||
if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
|
||||
if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
|
||||
{
|
||||
var tempWriter = new FastBufferWriter(NetworkBehaviour.NetworkManager.MessageManager.NonFragmentedMessageMaxSize, Allocator.Temp, NetworkBehaviour.NetworkManager.MessageManager.FragmentedMessageMaxSize);
|
||||
var tempWriter = new FastBufferWriter(networkManager.MessageManager.NonFragmentedMessageMaxSize, Allocator.Temp, networkManager.MessageManager.FragmentedMessageMaxSize);
|
||||
NetworkBehaviour.NetworkVariableFields[i].WriteDelta(tempWriter);
|
||||
BytePacker.WriteValueBitPacked(writer, tempWriter.Length);
|
||||
|
||||
@@ -105,9 +110,9 @@ namespace Unity.Netcode
|
||||
{
|
||||
networkVariable.WriteDelta(writer);
|
||||
}
|
||||
NetworkBehaviour.NetworkManager.NetworkMetrics.TrackNetworkVariableDeltaSent(
|
||||
networkManager.NetworkMetrics.TrackNetworkVariableDeltaSent(
|
||||
TargetClientId,
|
||||
NetworkBehaviour.NetworkObject,
|
||||
obj,
|
||||
networkVariable.Name,
|
||||
NetworkBehaviour.__getTypeName(),
|
||||
writer.Length - startingSize);
|
||||
|
||||
70
Runtime/Messaging/Messages/ProxyMessage.cs
Normal file
70
Runtime/Messaging/Messages/ProxyMessage.cs
Normal file
@@ -0,0 +1,70 @@
|
||||
using System;
|
||||
using Unity.Collections;
|
||||
|
||||
namespace Unity.Netcode
|
||||
{
|
||||
internal struct ProxyMessage : INetworkMessage
|
||||
{
|
||||
public NativeArray<ulong> TargetClientIds;
|
||||
public NetworkDelivery Delivery;
|
||||
public RpcMessage WrappedMessage;
|
||||
|
||||
// Version of ProxyMessage and RpcMessage must always match.
|
||||
// If ProxyMessage needs to change, increment RpcMessage's version
|
||||
public int Version => new RpcMessage().Version;
|
||||
|
||||
public void Serialize(FastBufferWriter writer, int targetVersion)
|
||||
{
|
||||
writer.WriteValueSafe(TargetClientIds);
|
||||
BytePacker.WriteValuePacked(writer, Delivery);
|
||||
WrappedMessage.Serialize(writer, targetVersion);
|
||||
}
|
||||
|
||||
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
|
||||
{
|
||||
reader.ReadValueSafe(out TargetClientIds, Allocator.Temp);
|
||||
ByteUnpacker.ReadValuePacked(reader, out Delivery);
|
||||
WrappedMessage = new RpcMessage();
|
||||
WrappedMessage.Deserialize(reader, ref context, receivedMessageVersion);
|
||||
return true;
|
||||
}
|
||||
|
||||
public unsafe void Handle(ref NetworkContext context)
|
||||
{
|
||||
|
||||
var networkManager = (NetworkManager)context.SystemOwner;
|
||||
if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(WrappedMessage.Metadata.NetworkObjectId, out var networkObject))
|
||||
{
|
||||
throw new InvalidOperationException($"An RPC called on a {nameof(NetworkObject)} that is not in the spawned objects list. Please make sure the {nameof(NetworkObject)} is spawned before calling RPCs.");
|
||||
}
|
||||
|
||||
var observers = networkObject.Observers;
|
||||
|
||||
var nonServerIds = new NativeList<ulong>(Allocator.Temp);
|
||||
for (var i = 0; i < TargetClientIds.Length; ++i)
|
||||
{
|
||||
if (!observers.Contains(TargetClientIds[i]))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (TargetClientIds[i] == NetworkManager.ServerClientId)
|
||||
{
|
||||
WrappedMessage.Handle(ref context);
|
||||
}
|
||||
else
|
||||
{
|
||||
nonServerIds.Add(TargetClientIds[i]);
|
||||
}
|
||||
}
|
||||
|
||||
WrappedMessage.WriteBuffer = new FastBufferWriter(WrappedMessage.ReadBuffer.Length, Allocator.Temp);
|
||||
|
||||
using (WrappedMessage.WriteBuffer)
|
||||
{
|
||||
WrappedMessage.WriteBuffer.WriteBytesSafe(WrappedMessage.ReadBuffer.GetUnsafePtr(), WrappedMessage.ReadBuffer.Length);
|
||||
networkManager.MessageManager.SendMessage(ref WrappedMessage, Delivery, nonServerIds);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
3
Runtime/Messaging/Messages/ProxyMessage.cs.meta
Normal file
3
Runtime/Messaging/Messages/ProxyMessage.cs.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: e9ee0457d5b740b38dfe6542658fb522
|
||||
timeCreated: 1697825043
|
||||
@@ -159,4 +159,42 @@ namespace Unity.Netcode
|
||||
RpcMessageHelpers.Handle(ref context, ref Metadata, ref ReadBuffer, ref rpcParams);
|
||||
}
|
||||
}
|
||||
|
||||
internal struct RpcMessage : INetworkMessage
|
||||
{
|
||||
public int Version => 0;
|
||||
|
||||
public RpcMetadata Metadata;
|
||||
public ulong SenderClientId;
|
||||
|
||||
public FastBufferWriter WriteBuffer;
|
||||
public FastBufferReader ReadBuffer;
|
||||
|
||||
public unsafe void Serialize(FastBufferWriter writer, int targetVersion)
|
||||
{
|
||||
BytePacker.WriteValuePacked(writer, SenderClientId);
|
||||
RpcMessageHelpers.Serialize(ref writer, ref Metadata, ref WriteBuffer);
|
||||
}
|
||||
|
||||
public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
|
||||
{
|
||||
ByteUnpacker.ReadValuePacked(reader, out SenderClientId);
|
||||
return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer);
|
||||
}
|
||||
|
||||
public void Handle(ref NetworkContext context)
|
||||
{
|
||||
var rpcParams = new __RpcParams
|
||||
{
|
||||
Ext = new RpcParams
|
||||
{
|
||||
Receive = new RpcReceiveParams
|
||||
{
|
||||
SenderClientId = SenderClientId
|
||||
}
|
||||
}
|
||||
};
|
||||
RpcMessageHelpers.Handle(ref context, ref Metadata, ref ReadBuffer, ref rpcParams);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
using System;
|
||||
using Unity.Netcode.Transports.UTP;
|
||||
|
||||
namespace Unity.Netcode
|
||||
{
|
||||
@@ -56,7 +57,8 @@ namespace Unity.Netcode
|
||||
{
|
||||
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
|
||||
{
|
||||
NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from a client on the server side. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
|
||||
var transportErrorMsg = GetTransportErrorMessage(messageContent, m_NetworkManager);
|
||||
NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from a client on the server side. {transportErrorMsg}");
|
||||
}
|
||||
|
||||
return false;
|
||||
@@ -66,7 +68,7 @@ namespace Unity.Netcode
|
||||
{
|
||||
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
|
||||
{
|
||||
NetworkLog.LogWarning($"Message received from {nameof(senderId)}={senderId} before it has been accepted");
|
||||
NetworkLog.LogWarning($"Message received from {nameof(senderId)}={senderId} before it has been accepted.");
|
||||
}
|
||||
|
||||
return false;
|
||||
@@ -76,7 +78,8 @@ namespace Unity.Netcode
|
||||
{
|
||||
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
|
||||
{
|
||||
NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from a client when the connection has already been established. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
|
||||
var transportErrorMsg = GetTransportErrorMessage(messageContent, m_NetworkManager);
|
||||
NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from a client when the connection has already been established. {transportErrorMsg}");
|
||||
}
|
||||
|
||||
return false;
|
||||
@@ -88,7 +91,8 @@ namespace Unity.Netcode
|
||||
{
|
||||
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
|
||||
{
|
||||
NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from the server on the client side. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
|
||||
var transportErrorMsg = GetTransportErrorMessage(messageContent, m_NetworkManager);
|
||||
NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from the server on the client side. {transportErrorMsg}");
|
||||
}
|
||||
|
||||
return false;
|
||||
@@ -98,7 +102,8 @@ namespace Unity.Netcode
|
||||
{
|
||||
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
|
||||
{
|
||||
NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from the server when the connection has already been established. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
|
||||
var transportErrorMsg = GetTransportErrorMessage(messageContent, m_NetworkManager);
|
||||
NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from the server when the connection has already been established. {transportErrorMsg}");
|
||||
}
|
||||
|
||||
return false;
|
||||
@@ -108,6 +113,28 @@ namespace Unity.Netcode
|
||||
return !m_NetworkManager.MessageManager.StopProcessing;
|
||||
}
|
||||
|
||||
private static string GetTransportErrorMessage(FastBufferReader messageContent, NetworkManager networkManager)
|
||||
{
|
||||
if (networkManager.NetworkConfig.NetworkTransport is not UnityTransport)
|
||||
{
|
||||
return $"NetworkTransport: {networkManager.NetworkConfig.NetworkTransport.GetType()}. Please report this to the maintainer of transport layer.";
|
||||
}
|
||||
|
||||
var transportVersion = GetTransportVersion(networkManager);
|
||||
return $"{transportVersion}. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}";
|
||||
}
|
||||
|
||||
private static string GetTransportVersion(NetworkManager networkManager)
|
||||
{
|
||||
var transportVersion = "NetworkTransport: " + networkManager.NetworkConfig.NetworkTransport.GetType();
|
||||
if (networkManager.NetworkConfig.NetworkTransport is UnityTransport unityTransport)
|
||||
{
|
||||
transportVersion += " UnityTransportProtocol: " + unityTransport.Protocol;
|
||||
}
|
||||
|
||||
return transportVersion;
|
||||
}
|
||||
|
||||
public void OnBeforeHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage
|
||||
{
|
||||
}
|
||||
|
||||
@@ -85,6 +85,8 @@ namespace Unity.Netcode
|
||||
private INetworkMessageSender m_Sender;
|
||||
private bool m_Disposed;
|
||||
|
||||
private ulong m_LocalClientId;
|
||||
|
||||
internal Type[] MessageTypes => m_ReverseTypeMap;
|
||||
internal MessageHandler[] MessageHandlers => m_MessageHandlers;
|
||||
|
||||
@@ -95,6 +97,16 @@ namespace Unity.Netcode
|
||||
return m_MessageTypes[t];
|
||||
}
|
||||
|
||||
internal object GetOwner()
|
||||
{
|
||||
return m_Owner;
|
||||
}
|
||||
|
||||
internal void SetLocalClientId(ulong id)
|
||||
{
|
||||
m_LocalClientId = id;
|
||||
}
|
||||
|
||||
public const int DefaultNonFragmentedMessageMaxSize = 1300 & ~7; // Round down to nearest word aligned size (1296)
|
||||
public int NonFragmentedMessageMaxSize = DefaultNonFragmentedMessageMaxSize;
|
||||
public int FragmentedMessageMaxSize = int.MaxValue;
|
||||
@@ -551,7 +563,7 @@ namespace Unity.Netcode
|
||||
// Special cases because these are the messages that carry the version info - thus the version info isn't
|
||||
// populated yet when we get these. The first part of these messages always has to be the version data
|
||||
// and can't change.
|
||||
if (typeof(T) != typeof(ConnectionRequestMessage) && typeof(T) != typeof(ConnectionApprovedMessage) && typeof(T) != typeof(DisconnectReasonMessage))
|
||||
if (typeof(T) != typeof(ConnectionRequestMessage) && typeof(T) != typeof(ConnectionApprovedMessage) && typeof(T) != typeof(DisconnectReasonMessage) && context.SenderId != manager.m_LocalClientId)
|
||||
{
|
||||
messageVersion = manager.GetMessageVersion(typeof(T), context.SenderId, true);
|
||||
if (messageVersion < 0)
|
||||
@@ -808,6 +820,12 @@ namespace Unity.Netcode
|
||||
return SendMessage(ref message, delivery, new PointerListWrapper<ulong>((ulong*)clientIds.GetUnsafePtr(), clientIds.Length));
|
||||
}
|
||||
|
||||
internal unsafe int SendMessage<T>(ref T message, NetworkDelivery delivery, in NativeList<ulong> clientIds)
|
||||
where T : INetworkMessage
|
||||
{
|
||||
return SendMessage(ref message, delivery, new PointerListWrapper<ulong>((ulong*)clientIds.GetUnsafePtr(), clientIds.Length));
|
||||
}
|
||||
|
||||
internal unsafe void ProcessSendQueues()
|
||||
{
|
||||
if (StopProcessing)
|
||||
|
||||
@@ -21,12 +21,36 @@ namespace Unity.Netcode
|
||||
/// <summary>
|
||||
/// <para>Represents the common base class for Rpc attributes.</para>
|
||||
/// </summary>
|
||||
public abstract class RpcAttribute : Attribute
|
||||
[AttributeUsage(AttributeTargets.Method)]
|
||||
public class RpcAttribute : Attribute
|
||||
{
|
||||
// Must match the set of parameters below
|
||||
public struct RpcAttributeParams
|
||||
{
|
||||
public RpcDelivery Delivery;
|
||||
public bool RequireOwnership;
|
||||
public bool DeferLocal;
|
||||
public bool AllowTargetOverride;
|
||||
}
|
||||
|
||||
// Must match the fields in RemoteAttributeParams
|
||||
/// <summary>
|
||||
/// Type of RPC delivery method
|
||||
/// </summary>
|
||||
public RpcDelivery Delivery = RpcDelivery.Reliable;
|
||||
public bool RequireOwnership;
|
||||
public bool DeferLocal;
|
||||
public bool AllowTargetOverride;
|
||||
|
||||
public RpcAttribute(SendTo target)
|
||||
{
|
||||
}
|
||||
|
||||
// To get around an issue with the release validator, RuntimeAccessModifiersILPP will make this 'public'
|
||||
private RpcAttribute()
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -36,10 +60,12 @@ namespace Unity.Netcode
|
||||
[AttributeUsage(AttributeTargets.Method)]
|
||||
public class ServerRpcAttribute : RpcAttribute
|
||||
{
|
||||
/// <summary>
|
||||
/// Whether or not the ServerRpc should only be run if executed by the owner of the object
|
||||
/// </summary>
|
||||
public bool RequireOwnership = true;
|
||||
public new bool RequireOwnership;
|
||||
|
||||
public ServerRpcAttribute() : base(SendTo.Server)
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -47,5 +73,11 @@ namespace Unity.Netcode
|
||||
/// <para>A ClientRpc marked method will be fired by the server but executed on clients.</para>
|
||||
/// </summary>
|
||||
[AttributeUsage(AttributeTargets.Method)]
|
||||
public class ClientRpcAttribute : RpcAttribute { }
|
||||
public class ClientRpcAttribute : RpcAttribute
|
||||
{
|
||||
public ClientRpcAttribute() : base(SendTo.NotServer)
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3,6 +3,60 @@ using Unity.Collections;
|
||||
|
||||
namespace Unity.Netcode
|
||||
{
|
||||
public enum LocalDeferMode
|
||||
{
|
||||
Default,
|
||||
Defer,
|
||||
SendImmediate
|
||||
}
|
||||
/// <summary>
|
||||
/// Generic RPC
|
||||
/// </summary>
|
||||
public struct RpcSendParams
|
||||
{
|
||||
public BaseRpcTarget Target;
|
||||
|
||||
public LocalDeferMode LocalDeferMode;
|
||||
|
||||
public static implicit operator RpcSendParams(BaseRpcTarget target) => new RpcSendParams { Target = target };
|
||||
public static implicit operator RpcSendParams(LocalDeferMode deferMode) => new RpcSendParams { LocalDeferMode = deferMode };
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The receive parameters for server-side remote procedure calls
|
||||
/// </summary>
|
||||
public struct RpcReceiveParams
|
||||
{
|
||||
/// <summary>
|
||||
/// Server-Side RPC
|
||||
/// The client identifier of the sender
|
||||
/// </summary>
|
||||
public ulong SenderClientId;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Server-Side RPC
|
||||
/// Can be used with any sever-side remote procedure call
|
||||
/// Note: typically this is use primarily for the <see cref="ServerRpcReceiveParams"/>
|
||||
/// </summary>
|
||||
public struct RpcParams
|
||||
{
|
||||
/// <summary>
|
||||
/// The server RPC send parameters (currently a place holder)
|
||||
/// </summary>
|
||||
public RpcSendParams Send;
|
||||
|
||||
/// <summary>
|
||||
/// The client RPC receive parameters provides you with the sender's identifier
|
||||
/// </summary>
|
||||
public RpcReceiveParams Receive;
|
||||
|
||||
public static implicit operator RpcParams(RpcSendParams send) => new RpcParams { Send = send };
|
||||
public static implicit operator RpcParams(BaseRpcTarget target) => new RpcParams { Send = new RpcSendParams { Target = target } };
|
||||
public static implicit operator RpcParams(LocalDeferMode deferMode) => new RpcParams { Send = new RpcSendParams { LocalDeferMode = deferMode } };
|
||||
public static implicit operator RpcParams(RpcReceiveParams receive) => new RpcParams { Receive = receive };
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Server-Side RPC
|
||||
/// Place holder. <see cref="ServerRpcParams"/>
|
||||
@@ -99,6 +153,7 @@ namespace Unity.Netcode
|
||||
internal struct __RpcParams
|
||||
#pragma warning restore IDE1006 // restore naming rule violation check
|
||||
{
|
||||
public RpcParams Ext;
|
||||
public ServerRpcParams Server;
|
||||
public ClientRpcParams Client;
|
||||
}
|
||||
|
||||
3
Runtime/Messaging/RpcTargets.meta
Normal file
3
Runtime/Messaging/RpcTargets.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: b02186acd1144e20acbd0dcb69b14938
|
||||
timeCreated: 1697824888
|
||||
57
Runtime/Messaging/RpcTargets/BaseRpcTarget.cs
Normal file
57
Runtime/Messaging/RpcTargets/BaseRpcTarget.cs
Normal 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
11
Runtime/Messaging/RpcTargets/BaseRpcTarget.cs.meta
Normal 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
37
Runtime/Messaging/RpcTargets/ClientsAndHostRpcTarget.cs
Normal 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)
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: c9f883d678ec4715b160dd9497d5f42d
|
||||
timeCreated: 1699481382
|
||||
34
Runtime/Messaging/RpcTargets/DirectSendRpcTarget.cs
Normal file
34
Runtime/Messaging/RpcTargets/DirectSendRpcTarget.cs
Normal 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
3
Runtime/Messaging/RpcTargets/DirectSendRpcTarget.cs.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 077544cfd0b94cfc8a2a55d3828b74bb
|
||||
timeCreated: 1697824873
|
||||
26
Runtime/Messaging/RpcTargets/EveryoneRpcTarget.cs
Normal file
26
Runtime/Messaging/RpcTargets/EveryoneRpcTarget.cs
Normal 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
3
Runtime/Messaging/RpcTargets/EveryoneRpcTarget.cs.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 675d4a5c79fc47078092ac15d255745d
|
||||
timeCreated: 1697824941
|
||||
9
Runtime/Messaging/RpcTargets/IGroupRpcTarget.cs
Normal file
9
Runtime/Messaging/RpcTargets/IGroupRpcTarget.cs
Normal 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
3
Runtime/Messaging/RpcTargets/IGroupRpcTarget.cs.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: beb19a6bb1334252a89b21c8490f7cbe
|
||||
timeCreated: 1697825109
|
||||
8
Runtime/Messaging/RpcTargets/IIndividualRpcTarget.cs
Normal file
8
Runtime/Messaging/RpcTargets/IIndividualRpcTarget.cs
Normal file
@@ -0,0 +1,8 @@
|
||||
namespace Unity.Netcode
|
||||
{
|
||||
internal interface IIndividualRpcTarget
|
||||
{
|
||||
void SetClientId(ulong clientId);
|
||||
BaseRpcTarget Target { get; }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: c658d9641f564d9890bef4f558f1cea6
|
||||
timeCreated: 1697825115
|
||||
67
Runtime/Messaging/RpcTargets/LocalSendRpcTarget.cs
Normal file
67
Runtime/Messaging/RpcTargets/LocalSendRpcTarget.cs
Normal 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
3
Runtime/Messaging/RpcTargets/LocalSendRpcTarget.cs.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: c3b290cdc20d4d2293652ec79652962a
|
||||
timeCreated: 1697824985
|
||||
71
Runtime/Messaging/RpcTargets/NotMeRpcTarget.cs
Normal file
71
Runtime/Messaging/RpcTargets/NotMeRpcTarget.cs
Normal file
@@ -0,0 +1,71 @@
|
||||
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;
|
||||
}
|
||||
if (clientId == NetworkManager.ServerClientId)
|
||||
{
|
||||
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
3
Runtime/Messaging/RpcTargets/NotMeRpcTarget.cs.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 99cd5e8be7bd454bab700ee08b8dad7b
|
||||
timeCreated: 1697824966
|
||||
91
Runtime/Messaging/RpcTargets/NotOwnerRpcTarget.cs
Normal file
91
Runtime/Messaging/RpcTargets/NotOwnerRpcTarget.cs
Normal file
@@ -0,0 +1,91 @@
|
||||
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 == NetworkManager.ServerClientId)
|
||||
{
|
||||
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 == 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);
|
||||
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
3
Runtime/Messaging/RpcTargets/NotOwnerRpcTarget.cs.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: d7bc66c5253b44d09ad978ea9e51c96f
|
||||
timeCreated: 1698789420
|
||||
72
Runtime/Messaging/RpcTargets/NotServerRpcTarget.cs
Normal file
72
Runtime/Messaging/RpcTargets/NotServerRpcTarget.cs
Normal 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
3
Runtime/Messaging/RpcTargets/NotServerRpcTarget.cs.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: c63787afe52f45ffbd5d801f78e7c0d6
|
||||
timeCreated: 1697824954
|
||||
54
Runtime/Messaging/RpcTargets/OwnerRpcTarget.cs
Normal file
54
Runtime/Messaging/RpcTargets/OwnerRpcTarget.cs
Normal 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
3
Runtime/Messaging/RpcTargets/OwnerRpcTarget.cs.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 23c4d52455fc419aaf03094617894257
|
||||
timeCreated: 1697824972
|
||||
16
Runtime/Messaging/RpcTargets/ProxyRpcTarget.cs
Normal file
16
Runtime/Messaging/RpcTargets/ProxyRpcTarget.cs
Normal 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
3
Runtime/Messaging/RpcTargets/ProxyRpcTarget.cs.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 86002805bb9e422e8b71581d1325357f
|
||||
timeCreated: 1697825007
|
||||
100
Runtime/Messaging/RpcTargets/ProxyRpcTargetGroup.cs
Normal file
100
Runtime/Messaging/RpcTargets/ProxyRpcTargetGroup.cs
Normal 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
3
Runtime/Messaging/RpcTargets/ProxyRpcTargetGroup.cs.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 5728dbab532e46a88127510b4ec75af9
|
||||
timeCreated: 1697825000
|
||||
564
Runtime/Messaging/RpcTargets/RpcTarget.cs
Normal file
564
Runtime/Messaging/RpcTargets/RpcTarget.cs
Normal 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<ulong>, 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<ulong>, 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
3
Runtime/Messaging/RpcTargets/RpcTarget.cs.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 1b26d0227e71408b918ae25ca2a0179b
|
||||
timeCreated: 1699555535
|
||||
80
Runtime/Messaging/RpcTargets/RpcTargetGroup.cs
Normal file
80
Runtime/Messaging/RpcTargets/RpcTargetGroup.cs
Normal 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
3
Runtime/Messaging/RpcTargets/RpcTargetGroup.cs.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 7f8c0fc053b64a588c99dd7d706d9f0a
|
||||
timeCreated: 1697824991
|
||||
36
Runtime/Messaging/RpcTargets/ServerRpcTarget.cs
Normal file
36
Runtime/Messaging/RpcTargets/ServerRpcTarget.cs
Normal 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
3
Runtime/Messaging/RpcTargets/ServerRpcTarget.cs.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: c911725afb6d44f3bb1a1d567d9dee0f
|
||||
timeCreated: 1697824979
|
||||
392
Runtime/NetworkVariable/AnticipatedNetworkVariable.cs
Normal file
392
Runtime/NetworkVariable/AnticipatedNetworkVariable.cs
Normal file
@@ -0,0 +1,392 @@
|
||||
using System;
|
||||
using Unity.Mathematics;
|
||||
using UnityEngine;
|
||||
|
||||
namespace Unity.Netcode
|
||||
{
|
||||
|
||||
public enum StaleDataHandling
|
||||
{
|
||||
Ignore,
|
||||
Reanticipate
|
||||
}
|
||||
|
||||
#pragma warning disable IDE0001
|
||||
/// <summary>
|
||||
/// A variable that can be synchronized over the network.
|
||||
/// This version supports basic client anticipation - the client can set a value on the belief that the server
|
||||
/// will update it to reflect the same value in a future update (i.e., as the result of an RPC call).
|
||||
/// This value can then be adjusted as new updates from the server come in, in three basic modes:
|
||||
///
|
||||
/// <list type="bullet">
|
||||
///
|
||||
/// <item><b>Snap:</b> In this mode (with <see cref="StaleDataHandling"/> set to
|
||||
/// <see cref="Netcode.StaleDataHandling.Ignore"/> and no <see cref="NetworkBehaviour.OnReanticipate"/> callback),
|
||||
/// the moment a more up-to-date value is received from the authority, it will simply replace the anticipated value,
|
||||
/// resulting in a "snap" to the new value if it is different from the anticipated value.</item>
|
||||
///
|
||||
/// <item><b>Smooth:</b> In this mode (with <see cref="StaleDataHandling"/> set to
|
||||
/// <see cref="Netcode.StaleDataHandling.Ignore"/> and an <see cref="NetworkBehaviour.OnReanticipate"/> callback that calls
|
||||
/// <see cref="Smooth"/> from the anticipated value to the authority value with an appropriate
|
||||
/// <see cref="Mathf.Lerp"/>-style smooth function), when a more up-to-date value is received from the authority,
|
||||
/// it will interpolate over time from an incorrect anticipated value to the correct authoritative value.</item>
|
||||
///
|
||||
/// <item><b>Constant Reanticipation:</b> In this mode (with <see cref="StaleDataHandling"/> set to
|
||||
/// <see cref="Netcode.StaleDataHandling.Reanticipate"/> and an <see cref="NetworkBehaviour.OnReanticipate"/> that calculates a
|
||||
/// new anticipated value based on the current authoritative value), when a more up-to-date value is received from
|
||||
/// the authority, user code calculates a new anticipated value, possibly calling <see cref="Smooth"/> to interpolate
|
||||
/// between the previous anticipation and the new anticipation. This is useful for values that change frequently and
|
||||
/// need to constantly be re-evaluated, as opposed to values that change only in response to user action and simply
|
||||
/// need a one-time anticipation when the user performs that action.</item>
|
||||
///
|
||||
/// </list>
|
||||
///
|
||||
/// Note that these three modes may be combined. For example, if an <see cref="NetworkBehaviour.OnReanticipate"/> callback
|
||||
/// does not call either <see cref="Smooth"/> or <see cref="Anticipate"/>, the result will be a snap to the
|
||||
/// authoritative value, enabling for a callback that may conditionally call <see cref="Smooth"/> when the
|
||||
/// difference between the anticipated and authoritative values is within some threshold, but fall back to
|
||||
/// snap behavior if the difference is too large.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">the unmanaged type for <see cref="NetworkVariable{T}"/> </typeparam>
|
||||
#pragma warning restore IDE0001
|
||||
[Serializable]
|
||||
[GenerateSerializationForGenericParameter(0)]
|
||||
public class AnticipatedNetworkVariable<T> : NetworkVariableBase
|
||||
{
|
||||
[SerializeField]
|
||||
private NetworkVariable<T> m_AuthoritativeValue;
|
||||
private T m_AnticipatedValue;
|
||||
private T m_PreviousAnticipatedValue;
|
||||
private ulong m_LastAuthorityUpdateCounter = 0;
|
||||
private ulong m_LastAnticipationCounter = 0;
|
||||
private bool m_IsDisposed = false;
|
||||
private bool m_SettingAuthoritativeValue = false;
|
||||
|
||||
private T m_SmoothFrom;
|
||||
private T m_SmoothTo;
|
||||
private float m_SmoothDuration;
|
||||
private float m_CurrentSmoothTime;
|
||||
private bool m_HasSmoothValues;
|
||||
|
||||
#pragma warning disable IDE0001
|
||||
/// <summary>
|
||||
/// Defines what the behavior should be if we receive a value from the server with an earlier associated
|
||||
/// time value than the anticipation time value.
|
||||
/// <br/><br/>
|
||||
/// If this is <see cref="Netcode.StaleDataHandling.Ignore"/>, the stale data will be ignored and the authoritative
|
||||
/// value will not replace the anticipated value until the anticipation time is reached. <see cref="OnAuthoritativeValueChanged"/>
|
||||
/// and <see cref="NetworkBehaviour.OnReanticipate"/> will also not be invoked for this stale data.
|
||||
/// <br/><br/>
|
||||
/// If this is <see cref="Netcode.StaleDataHandling.Reanticipate"/>, the stale data will replace the anticipated data and
|
||||
/// <see cref="OnAuthoritativeValueChanged"/> and <see cref="NetworkBehaviour.OnReanticipate"/> will be invoked.
|
||||
/// In this case, the authoritativeTime value passed to <see cref="NetworkBehaviour.OnReanticipate"/> will be lower than
|
||||
/// the anticipationTime value, and that callback can be used to calculate a new anticipated value.
|
||||
/// </summary>
|
||||
#pragma warning restore IDE0001
|
||||
public StaleDataHandling StaleDataHandling;
|
||||
|
||||
public delegate void OnAuthoritativeValueChangedDelegate(AnticipatedNetworkVariable<T> variable, in T previousValue, in T newValue);
|
||||
|
||||
/// <summary>
|
||||
/// Invoked any time the authoritative value changes, even when the data is stale or has been changed locally.
|
||||
/// </summary>
|
||||
public OnAuthoritativeValueChangedDelegate OnAuthoritativeValueChanged = null;
|
||||
|
||||
/// <summary>
|
||||
/// Determines if the difference between the last serialized value and the current value is large enough
|
||||
/// to serialize it again.
|
||||
/// </summary>
|
||||
public event NetworkVariable<T>.CheckExceedsDirtinessThresholdDelegate CheckExceedsDirtinessThreshold
|
||||
{
|
||||
add => m_AuthoritativeValue.CheckExceedsDirtinessThreshold += value;
|
||||
remove => m_AuthoritativeValue.CheckExceedsDirtinessThreshold -= value;
|
||||
}
|
||||
|
||||
private class AnticipatedObject : IAnticipatedObject
|
||||
{
|
||||
public AnticipatedNetworkVariable<T> Variable;
|
||||
|
||||
public void Update()
|
||||
{
|
||||
Variable.Update();
|
||||
}
|
||||
|
||||
public void ResetAnticipation()
|
||||
{
|
||||
Variable.ShouldReanticipate = false;
|
||||
}
|
||||
|
||||
public NetworkObject OwnerObject => Variable.m_NetworkBehaviour.NetworkObject;
|
||||
}
|
||||
|
||||
private AnticipatedObject m_AnticipatedObject;
|
||||
|
||||
public override void OnInitialize()
|
||||
{
|
||||
m_AuthoritativeValue.Initialize(m_NetworkBehaviour);
|
||||
NetworkVariableSerialization<T>.Duplicate(m_AuthoritativeValue.Value, ref m_AnticipatedValue);
|
||||
NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);
|
||||
if (m_NetworkBehaviour != null && m_NetworkBehaviour.NetworkManager != null && m_NetworkBehaviour.NetworkManager.AnticipationSystem != null)
|
||||
{
|
||||
m_AnticipatedObject = new AnticipatedObject { Variable = this };
|
||||
m_NetworkBehaviour.NetworkManager.AnticipationSystem.AllAnticipatedObjects.Add(m_AnticipatedObject);
|
||||
}
|
||||
}
|
||||
|
||||
public override bool ExceedsDirtinessThreshold()
|
||||
{
|
||||
return m_AuthoritativeValue.ExceedsDirtinessThreshold();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Retrieves the current value for the variable.
|
||||
/// This is the "display value" for this variable, and is affected by <see cref="Anticipate"/> and
|
||||
/// <see cref="Smooth"/>, as well as by updates from the authority, depending on <see cref="StaleDataHandling"/>
|
||||
/// and the behavior of any <see cref="NetworkBehaviour.OnReanticipate"/> callbacks.
|
||||
/// <br /><br />
|
||||
/// When a server update arrives, this value will be overwritten
|
||||
/// by the new server value (unless stale data handling is set
|
||||
/// to "Ignore" and the update is determined to be stale).
|
||||
/// This value will be duplicated in
|
||||
/// <see cref="PreviousAnticipatedValue"/>, which
|
||||
/// will NOT be overwritten in server updates.
|
||||
/// </summary>
|
||||
public T Value => m_AnticipatedValue;
|
||||
|
||||
/// <summary>
|
||||
/// Indicates whether this variable currently needs
|
||||
/// reanticipation. If this is true, the anticipated value
|
||||
/// has been overwritten by the authoritative value from the
|
||||
/// server; the previous anticipated value is stored in <see cref="PreviousAnticipatedState"/>
|
||||
/// </summary>
|
||||
public bool ShouldReanticipate
|
||||
{
|
||||
get;
|
||||
private set;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Holds the most recent anticipated value, whatever was
|
||||
/// most recently set using <see cref="Anticipate"/>. Unlike
|
||||
/// <see cref="Value"/>, this does not get overwritten
|
||||
/// when a server update arrives.
|
||||
/// </summary>
|
||||
public T PreviousAnticipatedValue => m_PreviousAnticipatedValue;
|
||||
|
||||
/// <summary>
|
||||
/// Sets the current value of the variable on the expectation that the authority will set the variable
|
||||
/// to the same value within one network round trip (i.e., in response to an RPC).
|
||||
/// </summary>
|
||||
/// <param name="value"></param>
|
||||
public void Anticipate(T value)
|
||||
{
|
||||
if (m_NetworkBehaviour.NetworkManager.ShutdownInProgress || !m_NetworkBehaviour.NetworkManager.IsListening)
|
||||
{
|
||||
return;
|
||||
}
|
||||
m_SmoothDuration = 0;
|
||||
m_CurrentSmoothTime = 0;
|
||||
m_LastAnticipationCounter = m_NetworkBehaviour.NetworkManager.AnticipationSystem.AnticipationCounter;
|
||||
m_AnticipatedValue = value;
|
||||
NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);
|
||||
if (CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId))
|
||||
{
|
||||
AuthoritativeValue = value;
|
||||
}
|
||||
}
|
||||
|
||||
#pragma warning disable IDE0001
|
||||
/// <summary>
|
||||
/// Retrieves or sets the underlying authoritative value.
|
||||
/// Note that only a client or server with write permissions to this variable may set this value.
|
||||
/// When this variable has been anticipated, this value will alawys return the most recent authoritative
|
||||
/// state, which is updated even if <see cref="StaleDataHandling"/> is <see cref="Netcode.StaleDataHandling.Ignore"/>.
|
||||
/// </summary>
|
||||
#pragma warning restore IDE0001
|
||||
public T AuthoritativeValue
|
||||
{
|
||||
get => m_AuthoritativeValue.Value;
|
||||
set
|
||||
{
|
||||
m_SettingAuthoritativeValue = true;
|
||||
try
|
||||
{
|
||||
m_AuthoritativeValue.Value = value;
|
||||
m_AnticipatedValue = value;
|
||||
NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);
|
||||
}
|
||||
finally
|
||||
{
|
||||
m_SettingAuthoritativeValue = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A function to interpolate between two values based on a percentage.
|
||||
/// See <see cref="Mathf.Lerp"/>, <see cref="Vector3.Lerp"/>, <see cref="Vector3.Slerp"/>, and so on
|
||||
/// for examples.
|
||||
/// </summary>
|
||||
public delegate T SmoothDelegate(T authoritativeValue, T anticipatedValue, float amount);
|
||||
|
||||
private SmoothDelegate m_SmoothDelegate = null;
|
||||
|
||||
public AnticipatedNetworkVariable(T value = default,
|
||||
StaleDataHandling staleDataHandling = StaleDataHandling.Ignore)
|
||||
: base()
|
||||
{
|
||||
StaleDataHandling = staleDataHandling;
|
||||
m_AuthoritativeValue = new NetworkVariable<T>(value)
|
||||
{
|
||||
OnValueChanged = OnValueChangedInternal
|
||||
};
|
||||
}
|
||||
|
||||
public void Update()
|
||||
{
|
||||
if (m_CurrentSmoothTime < m_SmoothDuration)
|
||||
{
|
||||
m_CurrentSmoothTime += m_NetworkBehaviour.NetworkManager.RealTimeProvider.DeltaTime;
|
||||
var pct = math.min(m_CurrentSmoothTime / m_SmoothDuration, 1f);
|
||||
m_AnticipatedValue = m_SmoothDelegate(m_SmoothFrom, m_SmoothTo, pct);
|
||||
NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);
|
||||
}
|
||||
}
|
||||
|
||||
public override void Dispose()
|
||||
{
|
||||
if (m_IsDisposed)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (m_NetworkBehaviour != null && m_NetworkBehaviour.NetworkManager != null && m_NetworkBehaviour.NetworkManager.AnticipationSystem != null)
|
||||
{
|
||||
if (m_AnticipatedObject != null)
|
||||
{
|
||||
m_NetworkBehaviour.NetworkManager.AnticipationSystem.AllAnticipatedObjects.Remove(m_AnticipatedObject);
|
||||
m_NetworkBehaviour.NetworkManager.AnticipationSystem.ObjectsToReanticipate.Remove(m_AnticipatedObject);
|
||||
m_AnticipatedObject = null;
|
||||
}
|
||||
}
|
||||
|
||||
m_IsDisposed = true;
|
||||
|
||||
m_AuthoritativeValue.Dispose();
|
||||
if (m_AnticipatedValue is IDisposable anticipatedValueDisposable)
|
||||
{
|
||||
anticipatedValueDisposable.Dispose();
|
||||
}
|
||||
|
||||
m_AnticipatedValue = default;
|
||||
if (m_PreviousAnticipatedValue is IDisposable previousValueDisposable)
|
||||
{
|
||||
previousValueDisposable.Dispose();
|
||||
m_PreviousAnticipatedValue = default;
|
||||
}
|
||||
|
||||
if (m_HasSmoothValues)
|
||||
{
|
||||
if (m_SmoothFrom is IDisposable smoothFromDisposable)
|
||||
{
|
||||
smoothFromDisposable.Dispose();
|
||||
m_SmoothFrom = default;
|
||||
}
|
||||
if (m_SmoothTo is IDisposable smoothToDisposable)
|
||||
{
|
||||
smoothToDisposable.Dispose();
|
||||
m_SmoothTo = default;
|
||||
}
|
||||
|
||||
m_HasSmoothValues = false;
|
||||
}
|
||||
}
|
||||
|
||||
~AnticipatedNetworkVariable()
|
||||
{
|
||||
Dispose();
|
||||
}
|
||||
|
||||
private void OnValueChangedInternal(T previousValue, T newValue)
|
||||
{
|
||||
if (!m_SettingAuthoritativeValue)
|
||||
{
|
||||
m_LastAuthorityUpdateCounter = m_NetworkBehaviour.NetworkManager.AnticipationSystem.LastAnticipationAck;
|
||||
if (StaleDataHandling == StaleDataHandling.Ignore && m_LastAnticipationCounter > m_LastAuthorityUpdateCounter)
|
||||
{
|
||||
// Keep the anticipated value unchanged because it is more recent than the authoritative one.
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
ShouldReanticipate = true;
|
||||
m_NetworkBehaviour.NetworkManager.AnticipationSystem.ObjectsToReanticipate.Add(m_AnticipatedObject);
|
||||
}
|
||||
|
||||
NetworkVariableSerialization<T>.Duplicate(AuthoritativeValue, ref m_AnticipatedValue);
|
||||
|
||||
m_SmoothDuration = 0;
|
||||
m_CurrentSmoothTime = 0;
|
||||
OnAuthoritativeValueChanged?.Invoke(this, previousValue, newValue);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Interpolate this variable from <see cref="from"/> to <see cref="to"/> over <see cref="durationSeconds"/> of
|
||||
/// real time. The duration uses <see cref="Time.deltaTime"/>, so it is affected by <see cref="Time.timeScale"/>.
|
||||
/// </summary>
|
||||
/// <param name="from"></param>
|
||||
/// <param name="to"></param>
|
||||
/// <param name="durationSeconds"></param>
|
||||
/// <param name="how"></param>
|
||||
public void Smooth(in T from, in T to, float durationSeconds, SmoothDelegate how)
|
||||
{
|
||||
if (durationSeconds <= 0)
|
||||
{
|
||||
NetworkVariableSerialization<T>.Duplicate(to, ref m_AnticipatedValue);
|
||||
m_SmoothDuration = 0;
|
||||
m_CurrentSmoothTime = 0;
|
||||
m_SmoothDelegate = null;
|
||||
return;
|
||||
}
|
||||
NetworkVariableSerialization<T>.Duplicate(from, ref m_AnticipatedValue);
|
||||
NetworkVariableSerialization<T>.Duplicate(from, ref m_SmoothFrom);
|
||||
NetworkVariableSerialization<T>.Duplicate(to, ref m_SmoothTo);
|
||||
m_SmoothDuration = durationSeconds;
|
||||
m_CurrentSmoothTime = 0;
|
||||
m_SmoothDelegate = how;
|
||||
m_HasSmoothValues = true;
|
||||
}
|
||||
|
||||
public override bool IsDirty()
|
||||
{
|
||||
return m_AuthoritativeValue.IsDirty();
|
||||
}
|
||||
|
||||
public override void ResetDirty()
|
||||
{
|
||||
m_AuthoritativeValue.ResetDirty();
|
||||
}
|
||||
|
||||
public override void WriteDelta(FastBufferWriter writer)
|
||||
{
|
||||
m_AuthoritativeValue.WriteDelta(writer);
|
||||
}
|
||||
|
||||
public override void WriteField(FastBufferWriter writer)
|
||||
{
|
||||
m_AuthoritativeValue.WriteField(writer);
|
||||
}
|
||||
|
||||
public override void ReadField(FastBufferReader reader)
|
||||
{
|
||||
m_AuthoritativeValue.ReadField(reader);
|
||||
NetworkVariableSerialization<T>.Duplicate(m_AuthoritativeValue.Value, ref m_AnticipatedValue);
|
||||
NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);
|
||||
}
|
||||
|
||||
public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
|
||||
{
|
||||
m_AuthoritativeValue.ReadDelta(reader, keepDirtyDelta);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 10f5188736b742d1993a2aad46a03e78
|
||||
timeCreated: 1705595868
|
||||
746
Runtime/NetworkVariable/CollectionSerializationUtility.cs
Normal file
746
Runtime/NetworkVariable/CollectionSerializationUtility.cs
Normal file
@@ -0,0 +1,746 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using Unity.Collections;
|
||||
using Unity.Collections.LowLevel.Unsafe;
|
||||
using Unity.Mathematics;
|
||||
|
||||
namespace Unity.Netcode
|
||||
{
|
||||
internal static class CollectionSerializationUtility
|
||||
{
|
||||
public static void WriteNativeArrayDelta<T>(FastBufferWriter writer, ref NativeArray<T> value, ref NativeArray<T> previousValue) where T : unmanaged
|
||||
{
|
||||
// This bit vector serializes the list of which fields have changed using 1 bit per field.
|
||||
// This will always be 1 bit per field of the whole array (rounded up to the nearest 8 bits)
|
||||
// even if there is only one change, so as compared to serializing the index with each item,
|
||||
// this will use more bandwidth when the overall bandwidth usage is small and the array is large,
|
||||
// but less when the overall bandwidth usage is large. So it optimizes for the worst case while accepting
|
||||
// some reduction in efficiency in the best case.
|
||||
using var changes = new ResizableBitVector(Allocator.Temp);
|
||||
int minLength = math.min(value.Length, previousValue.Length);
|
||||
var numChanges = 0;
|
||||
// Iterate the array, checking which values have changed and marking that in the bit vector
|
||||
for (var i = 0; i < minLength; ++i)
|
||||
{
|
||||
var val = value[i];
|
||||
var prevVal = previousValue[i];
|
||||
if (!NetworkVariableSerialization<T>.AreEqual(ref val, ref prevVal))
|
||||
{
|
||||
++numChanges;
|
||||
changes.Set(i);
|
||||
}
|
||||
}
|
||||
|
||||
// Mark any newly added items as well
|
||||
// We don't need to mark removed items because they are captured by serializing the length
|
||||
for (var i = previousValue.Length; i < value.Length; ++i)
|
||||
{
|
||||
++numChanges;
|
||||
changes.Set(i);
|
||||
}
|
||||
|
||||
// If the size of serializing the dela is greater than the size of serializing the whole array (i.e.,
|
||||
// because almost the entire array has changed and the overhead of the change set increases bandwidth),
|
||||
// then we just do a normal full serialization instead of a delta.
|
||||
if (changes.GetSerializedSize() + FastBufferWriter.GetWriteSize<T>() * numChanges > FastBufferWriter.GetWriteSize<T>() * value.Length)
|
||||
{
|
||||
// 1 = full serialization
|
||||
writer.WriteByteSafe(1);
|
||||
writer.WriteValueSafe(value);
|
||||
return;
|
||||
}
|
||||
// 0 = delta serialization
|
||||
writer.WriteByte(0);
|
||||
// Write the length, which will be used on the read side to resize the array
|
||||
BytePacker.WriteValuePacked(writer, value.Length);
|
||||
writer.WriteValueSafe(changes);
|
||||
unsafe
|
||||
{
|
||||
var ptr = (T*)value.GetUnsafePtr();
|
||||
var prevPtr = (T*)previousValue.GetUnsafePtr();
|
||||
for (int i = 0; i < value.Length; ++i)
|
||||
{
|
||||
if (changes.IsSet(i))
|
||||
{
|
||||
if (i < previousValue.Length)
|
||||
{
|
||||
// If we have an item in the previous array for this index, we can do nested deltas!
|
||||
NetworkVariableSerialization<T>.WriteDelta(writer, ref ptr[i], ref prevPtr[i]);
|
||||
}
|
||||
else
|
||||
{
|
||||
// If not, just write it normally
|
||||
NetworkVariableSerialization<T>.Write(writer, ref ptr[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
public static void ReadNativeArrayDelta<T>(FastBufferReader reader, ref NativeArray<T> value) where T : unmanaged
|
||||
{
|
||||
// 1 = full serialization, 0 = delta serialization
|
||||
reader.ReadByteSafe(out byte full);
|
||||
if (full == 1)
|
||||
{
|
||||
// If we're doing full serialization, we fall back on reading the whole array.
|
||||
value.Dispose();
|
||||
reader.ReadValueSafe(out value, Allocator.Persistent);
|
||||
return;
|
||||
}
|
||||
// If not, first read the length and the change bits
|
||||
ByteUnpacker.ReadValuePacked(reader, out int length);
|
||||
var changes = new ResizableBitVector(Allocator.Temp);
|
||||
using var toDispose = changes;
|
||||
{
|
||||
reader.ReadNetworkSerializableInPlace(ref changes);
|
||||
|
||||
// If the length has changed, we need to resize.
|
||||
// NativeArray is not resizeable, so we have to dispose and allocate a new one.
|
||||
var previousLength = value.Length;
|
||||
if (length != value.Length)
|
||||
{
|
||||
var newArray = new NativeArray<T>(length, Allocator.Persistent);
|
||||
unsafe
|
||||
{
|
||||
UnsafeUtility.MemCpy(newArray.GetUnsafePtr(), value.GetUnsafePtr(), math.min(newArray.Length * sizeof(T), value.Length * sizeof(T)));
|
||||
}
|
||||
value.Dispose();
|
||||
value = newArray;
|
||||
}
|
||||
|
||||
unsafe
|
||||
{
|
||||
var ptr = (T*)value.GetUnsafePtr();
|
||||
for (var i = 0; i < value.Length; ++i)
|
||||
{
|
||||
if (changes.IsSet(i))
|
||||
{
|
||||
if (i < previousLength)
|
||||
{
|
||||
// If we have an item to read a delta into, read it as a delta
|
||||
NetworkVariableSerialization<T>.ReadDelta(reader, ref ptr[i]);
|
||||
}
|
||||
else
|
||||
{
|
||||
// If not, read as a standard element
|
||||
NetworkVariableSerialization<T>.Read(reader, ref ptr[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
public static void WriteListDelta<T>(FastBufferWriter writer, ref List<T> value, ref List<T> previousValue)
|
||||
{
|
||||
// Lists can be null, so we have to handle that case.
|
||||
// We do that by marking this as a full serialization and using the existing null handling logic
|
||||
// in NetworkVariableSerialization<List<T>>
|
||||
if (value == null || previousValue == null)
|
||||
{
|
||||
writer.WriteByteSafe(1);
|
||||
NetworkVariableSerialization<List<T>>.Write(writer, ref value);
|
||||
return;
|
||||
}
|
||||
// This bit vector serializes the list of which fields have changed using 1 bit per field.
|
||||
// This will always be 1 bit per field of the whole array (rounded up to the nearest 8 bits)
|
||||
// even if there is only one change, so as compared to serializing the index with each item,
|
||||
// this will use more bandwidth when the overall bandwidth usage is small and the array is large,
|
||||
// but less when the overall bandwidth usage is large. So it optimizes for the worst case while accepting
|
||||
// some reduction in efficiency in the best case.
|
||||
using var changes = new ResizableBitVector(Allocator.Temp);
|
||||
int minLength = math.min(value.Count, previousValue.Count);
|
||||
var numChanges = 0;
|
||||
// Iterate the list, checking which values have changed and marking that in the bit vector
|
||||
for (var i = 0; i < minLength; ++i)
|
||||
{
|
||||
var val = value[i];
|
||||
var prevVal = previousValue[i];
|
||||
if (!NetworkVariableSerialization<T>.AreEqual(ref val, ref prevVal))
|
||||
{
|
||||
++numChanges;
|
||||
changes.Set(i);
|
||||
}
|
||||
}
|
||||
|
||||
// Mark any newly added items as well
|
||||
// We don't need to mark removed items because they are captured by serializing the length
|
||||
for (var i = previousValue.Count; i < value.Count; ++i)
|
||||
{
|
||||
++numChanges;
|
||||
changes.Set(i);
|
||||
}
|
||||
|
||||
// If the size of serializing the dela is greater than the size of serializing the whole array (i.e.,
|
||||
// because almost the entire array has changed and the overhead of the change set increases bandwidth),
|
||||
// then we just do a normal full serialization instead of a delta.
|
||||
// In the case of List<T>, it's difficult to know exactly what the serialized size is going to be before
|
||||
// we serialize it, so we fudge it.
|
||||
if (numChanges >= value.Count * 0.9)
|
||||
{
|
||||
// 1 = full serialization
|
||||
writer.WriteByteSafe(1);
|
||||
NetworkVariableSerialization<List<T>>.Write(writer, ref value);
|
||||
return;
|
||||
}
|
||||
|
||||
// 0 = delta serialization
|
||||
writer.WriteByteSafe(0);
|
||||
// Write the length, which will be used on the read side to resize the list
|
||||
BytePacker.WriteValuePacked(writer, value.Count);
|
||||
writer.WriteValueSafe(changes);
|
||||
for (int i = 0; i < value.Count; ++i)
|
||||
{
|
||||
if (changes.IsSet(i))
|
||||
{
|
||||
var reffable = value[i];
|
||||
if (i < previousValue.Count)
|
||||
{
|
||||
// If we have an item in the previous array for this index, we can do nested deltas!
|
||||
var prevReffable = previousValue[i];
|
||||
NetworkVariableSerialization<T>.WriteDelta(writer, ref reffable, ref prevReffable);
|
||||
}
|
||||
else
|
||||
{
|
||||
// If not, just write it normally.
|
||||
NetworkVariableSerialization<T>.Write(writer, ref reffable);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
public static void ReadListDelta<T>(FastBufferReader reader, ref List<T> value)
|
||||
{
|
||||
// 1 = full serialization, 0 = delta serialization
|
||||
reader.ReadByteSafe(out byte full);
|
||||
if (full == 1)
|
||||
{
|
||||
// If we're doing full serialization, we fall back on reading the whole list.
|
||||
NetworkVariableSerialization<List<T>>.Read(reader, ref value);
|
||||
return;
|
||||
}
|
||||
// If not, first read the length and the change bits
|
||||
ByteUnpacker.ReadValuePacked(reader, out int length);
|
||||
var changes = new ResizableBitVector(Allocator.Temp);
|
||||
using var toDispose = changes;
|
||||
{
|
||||
reader.ReadNetworkSerializableInPlace(ref changes);
|
||||
|
||||
// If the list shrank, we need to resize it down.
|
||||
// List<T> has no method to reserve space for future elements,
|
||||
// so if we have to grow it, we just do that using Add() below.
|
||||
if (length < value.Count)
|
||||
{
|
||||
value.RemoveRange(length, value.Count - length);
|
||||
}
|
||||
|
||||
for (var i = 0; i < length; ++i)
|
||||
{
|
||||
if (changes.IsSet(i))
|
||||
{
|
||||
if (i < value.Count)
|
||||
{
|
||||
// If we have an item to read a delta into, read it as a delta
|
||||
T item = value[i];
|
||||
NetworkVariableSerialization<T>.ReadDelta(reader, ref item);
|
||||
value[i] = item;
|
||||
}
|
||||
else
|
||||
{
|
||||
// If not, just read it as a standard item.
|
||||
T item = default;
|
||||
NetworkVariableSerialization<T>.Read(reader, ref item);
|
||||
value.Add(item);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// For HashSet and Dictionary, we need to have some local space to hold lists we need to serialize.
|
||||
// We don't want to do allocations all the time and we know each one needs a maximum of three lists,
|
||||
// so we're going to keep static lists that we can reuse in these methods.
|
||||
private static class ListCache<T>
|
||||
{
|
||||
private static List<T> s_AddedList = new List<T>();
|
||||
private static List<T> s_RemovedList = new List<T>();
|
||||
private static List<T> s_ChangedList = new List<T>();
|
||||
|
||||
public static List<T> GetAddedList()
|
||||
{
|
||||
s_AddedList.Clear();
|
||||
return s_AddedList;
|
||||
}
|
||||
public static List<T> GetRemovedList()
|
||||
{
|
||||
s_RemovedList.Clear();
|
||||
return s_RemovedList;
|
||||
}
|
||||
public static List<T> GetChangedList()
|
||||
{
|
||||
s_ChangedList.Clear();
|
||||
return s_ChangedList;
|
||||
}
|
||||
}
|
||||
|
||||
public static void WriteHashSetDelta<T>(FastBufferWriter writer, ref HashSet<T> value, ref HashSet<T> previousValue) where T : IEquatable<T>
|
||||
{
|
||||
// HashSets can be null, so we have to handle that case.
|
||||
// We do that by marking this as a full serialization and using the existing null handling logic
|
||||
// in NetworkVariableSerialization<HashSet<T>>
|
||||
if (value == null || previousValue == null)
|
||||
{
|
||||
writer.WriteByteSafe(1);
|
||||
NetworkVariableSerialization<HashSet<T>>.Write(writer, ref value);
|
||||
return;
|
||||
}
|
||||
// No changed array because a set can't have a "changed" element, only added and removed.
|
||||
var added = ListCache<T>.GetAddedList();
|
||||
var removed = ListCache<T>.GetRemovedList();
|
||||
// collect the new elements
|
||||
foreach (var item in value)
|
||||
{
|
||||
if (!previousValue.Contains(item))
|
||||
{
|
||||
added.Add(item);
|
||||
}
|
||||
}
|
||||
|
||||
// collect the removed elements
|
||||
foreach (var item in previousValue)
|
||||
{
|
||||
if (!value.Contains(item))
|
||||
{
|
||||
removed.Add(item);
|
||||
}
|
||||
}
|
||||
|
||||
// If we've got more changes than total items, we just do a full serialization
|
||||
if (added.Count + removed.Count >= value.Count)
|
||||
{
|
||||
writer.WriteByteSafe(1);
|
||||
NetworkVariableSerialization<HashSet<T>>.Write(writer, ref value);
|
||||
return;
|
||||
}
|
||||
|
||||
writer.WriteByteSafe(0);
|
||||
// Write out the added and removed arrays.
|
||||
writer.WriteValueSafe(added.Count);
|
||||
for (var i = 0; i < added.Count; ++i)
|
||||
{
|
||||
var item = added[i];
|
||||
NetworkVariableSerialization<T>.Write(writer, ref item);
|
||||
}
|
||||
writer.WriteValueSafe(removed.Count);
|
||||
for (var i = 0; i < removed.Count; ++i)
|
||||
{
|
||||
var item = removed[i];
|
||||
NetworkVariableSerialization<T>.Write(writer, ref item);
|
||||
}
|
||||
}
|
||||
|
||||
public static void ReadHashSetDelta<T>(FastBufferReader reader, ref HashSet<T> value) where T : IEquatable<T>
|
||||
{
|
||||
// 1 = full serialization, 0 = delta serialization
|
||||
reader.ReadByteSafe(out byte full);
|
||||
if (full != 0)
|
||||
{
|
||||
NetworkVariableSerialization<HashSet<T>>.Read(reader, ref value);
|
||||
return;
|
||||
}
|
||||
// Read in the added and removed values
|
||||
reader.ReadValueSafe(out int addedCount);
|
||||
for (var i = 0; i < addedCount; ++i)
|
||||
{
|
||||
T item = default;
|
||||
NetworkVariableSerialization<T>.Read(reader, ref item);
|
||||
value.Add(item);
|
||||
}
|
||||
reader.ReadValueSafe(out int removedCount);
|
||||
for (var i = 0; i < removedCount; ++i)
|
||||
{
|
||||
T item = default;
|
||||
NetworkVariableSerialization<T>.Read(reader, ref item);
|
||||
value.Remove(item);
|
||||
}
|
||||
}
|
||||
public static void WriteDictionaryDelta<TKey, TVal>(FastBufferWriter writer, ref Dictionary<TKey, TVal> value, ref Dictionary<TKey, TVal> previousValue)
|
||||
where TKey : IEquatable<TKey>
|
||||
{
|
||||
if (value == null || previousValue == null)
|
||||
{
|
||||
writer.WriteByteSafe(1);
|
||||
NetworkVariableSerialization<Dictionary<TKey, TVal>>.Write(writer, ref value);
|
||||
return;
|
||||
}
|
||||
var added = ListCache<KeyValuePair<TKey, TVal>>.GetAddedList();
|
||||
var changed = ListCache<KeyValuePair<TKey, TVal>>.GetRemovedList();
|
||||
var removed = ListCache<KeyValuePair<TKey, TVal>>.GetChangedList();
|
||||
// Collect items that have been added or have changed
|
||||
foreach (var item in value)
|
||||
{
|
||||
var val = item.Value;
|
||||
var hasPrevVal = previousValue.TryGetValue(item.Key, out var prevVal);
|
||||
if (!hasPrevVal)
|
||||
{
|
||||
added.Add(item);
|
||||
}
|
||||
else if (!NetworkVariableSerialization<TVal>.AreEqual(ref val, ref prevVal))
|
||||
{
|
||||
changed.Add(item);
|
||||
}
|
||||
}
|
||||
|
||||
// collect the items that have been removed
|
||||
foreach (var item in previousValue)
|
||||
{
|
||||
if (!value.ContainsKey(item.Key))
|
||||
{
|
||||
removed.Add(item);
|
||||
}
|
||||
}
|
||||
|
||||
// If there are more changes than total values, just do a full serialization
|
||||
if (added.Count + removed.Count + changed.Count >= value.Count)
|
||||
{
|
||||
writer.WriteByteSafe(1);
|
||||
NetworkVariableSerialization<Dictionary<TKey, TVal>>.Write(writer, ref value);
|
||||
return;
|
||||
}
|
||||
|
||||
writer.WriteByteSafe(0);
|
||||
// Else, write out the added, removed, and changed arrays
|
||||
writer.WriteValueSafe(added.Count);
|
||||
for (var i = 0; i < added.Count; ++i)
|
||||
{
|
||||
(var key, var val) = (added[i].Key, added[i].Value);
|
||||
NetworkVariableSerialization<TKey>.Write(writer, ref key);
|
||||
NetworkVariableSerialization<TVal>.Write(writer, ref val);
|
||||
}
|
||||
writer.WriteValueSafe(removed.Count);
|
||||
for (var i = 0; i < removed.Count; ++i)
|
||||
{
|
||||
var key = removed[i].Key;
|
||||
NetworkVariableSerialization<TKey>.Write(writer, ref key);
|
||||
}
|
||||
writer.WriteValueSafe(changed.Count);
|
||||
for (var i = 0; i < changed.Count; ++i)
|
||||
{
|
||||
(var key, var val) = (changed[i].Key, changed[i].Value);
|
||||
NetworkVariableSerialization<TKey>.Write(writer, ref key);
|
||||
NetworkVariableSerialization<TVal>.Write(writer, ref val);
|
||||
}
|
||||
}
|
||||
|
||||
public static void ReadDictionaryDelta<TKey, TVal>(FastBufferReader reader, ref Dictionary<TKey, TVal> value)
|
||||
where TKey : IEquatable<TKey>
|
||||
{
|
||||
// 1 = full serialization, 0 = delta serialization
|
||||
reader.ReadByteSafe(out byte full);
|
||||
if (full != 0)
|
||||
{
|
||||
NetworkVariableSerialization<Dictionary<TKey, TVal>>.Read(reader, ref value);
|
||||
return;
|
||||
}
|
||||
// Added
|
||||
reader.ReadValueSafe(out int length);
|
||||
for (var i = 0; i < length; ++i)
|
||||
{
|
||||
(TKey key, TVal val) = (default, default);
|
||||
NetworkVariableSerialization<TKey>.Read(reader, ref key);
|
||||
NetworkVariableSerialization<TVal>.Read(reader, ref val);
|
||||
value.Add(key, val);
|
||||
}
|
||||
// Removed
|
||||
reader.ReadValueSafe(out length);
|
||||
for (var i = 0; i < length; ++i)
|
||||
{
|
||||
TKey key = default;
|
||||
NetworkVariableSerialization<TKey>.Read(reader, ref key);
|
||||
value.Remove(key);
|
||||
}
|
||||
// Changed
|
||||
reader.ReadValueSafe(out length);
|
||||
for (var i = 0; i < length; ++i)
|
||||
{
|
||||
(TKey key, TVal val) = (default, default);
|
||||
NetworkVariableSerialization<TKey>.Read(reader, ref key);
|
||||
NetworkVariableSerialization<TVal>.Read(reader, ref val);
|
||||
value[key] = val;
|
||||
}
|
||||
}
|
||||
|
||||
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
|
||||
public static void WriteNativeListDelta<T>(FastBufferWriter writer, ref NativeList<T> value, ref NativeList<T> previousValue) where T : unmanaged
|
||||
{
|
||||
// See WriteListDelta and WriteNativeArrayDelta to understand most of this. It's basically the same,
|
||||
// just adjusted for the NativeList API
|
||||
using var changes = new ResizableBitVector(Allocator.Temp);
|
||||
int minLength = math.min(value.Length, previousValue.Length);
|
||||
var numChanges = 0;
|
||||
for (var i = 0; i < minLength; ++i)
|
||||
{
|
||||
var val = value[i];
|
||||
var prevVal = previousValue[i];
|
||||
if (!NetworkVariableSerialization<T>.AreEqual(ref val, ref prevVal))
|
||||
{
|
||||
++numChanges;
|
||||
changes.Set(i);
|
||||
}
|
||||
}
|
||||
|
||||
for (var i = previousValue.Length; i < value.Length; ++i)
|
||||
{
|
||||
++numChanges;
|
||||
changes.Set(i);
|
||||
}
|
||||
|
||||
if (changes.GetSerializedSize() + FastBufferWriter.GetWriteSize<T>() * numChanges > FastBufferWriter.GetWriteSize<T>() * value.Length)
|
||||
{
|
||||
writer.WriteByteSafe(1);
|
||||
writer.WriteValueSafe(value);
|
||||
return;
|
||||
}
|
||||
|
||||
writer.WriteByte(0);
|
||||
BytePacker.WriteValuePacked(writer, value.Length);
|
||||
writer.WriteValueSafe(changes);
|
||||
unsafe
|
||||
{
|
||||
var ptr = (T*)value.GetUnsafePtr();
|
||||
var prevPtr = (T*)previousValue.GetUnsafePtr();
|
||||
for (int i = 0; i < value.Length; ++i)
|
||||
{
|
||||
if (changes.IsSet(i))
|
||||
{
|
||||
if (i < previousValue.Length)
|
||||
{
|
||||
NetworkVariableSerialization<T>.WriteDelta(writer, ref ptr[i], ref prevPtr[i]);
|
||||
}
|
||||
else
|
||||
{
|
||||
NetworkVariableSerialization<T>.Write(writer, ref ptr[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
public static void ReadNativeListDelta<T>(FastBufferReader reader, ref NativeList<T> value) where T : unmanaged
|
||||
{
|
||||
// See ReadListDelta and ReadNativeArrayDelta to understand most of this. It's basically the same,
|
||||
// just adjusted for the NativeList API
|
||||
reader.ReadByteSafe(out byte full);
|
||||
if (full == 1)
|
||||
{
|
||||
reader.ReadValueSafeInPlace(ref value);
|
||||
return;
|
||||
}
|
||||
ByteUnpacker.ReadValuePacked(reader, out int length);
|
||||
var changes = new ResizableBitVector(Allocator.Temp);
|
||||
using var toDispose = changes;
|
||||
{
|
||||
reader.ReadNetworkSerializableInPlace(ref changes);
|
||||
|
||||
var previousLength = value.Length;
|
||||
// The one big difference between this and NativeArray/List is that NativeList supports
|
||||
// easy and fast resizing and reserving space.
|
||||
if (length != value.Length)
|
||||
{
|
||||
value.Resize(length, NativeArrayOptions.UninitializedMemory);
|
||||
}
|
||||
|
||||
unsafe
|
||||
{
|
||||
var ptr = (T*)value.GetUnsafePtr();
|
||||
for (var i = 0; i < value.Length; ++i)
|
||||
{
|
||||
if (changes.IsSet(i))
|
||||
{
|
||||
if (i < previousLength)
|
||||
{
|
||||
NetworkVariableSerialization<T>.ReadDelta(reader, ref ptr[i]);
|
||||
}
|
||||
else
|
||||
{
|
||||
NetworkVariableSerialization<T>.Read(reader, ref ptr[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static unsafe void WriteNativeHashSetDelta<T>(FastBufferWriter writer, ref NativeHashSet<T> value, ref NativeHashSet<T> previousValue) where T : unmanaged, IEquatable<T>
|
||||
{
|
||||
// See WriteHashSet; this is the same algorithm, adjusted for the NativeHashSet API
|
||||
var added = stackalloc T[value.Count()];
|
||||
var removed = stackalloc T[previousValue.Count()];
|
||||
var addedCount = 0;
|
||||
var removedCount = 0;
|
||||
foreach (var item in value)
|
||||
{
|
||||
if (!previousValue.Contains(item))
|
||||
{
|
||||
added[addedCount] = item;
|
||||
++addedCount;
|
||||
}
|
||||
}
|
||||
|
||||
foreach (var item in previousValue)
|
||||
{
|
||||
if (!value.Contains(item))
|
||||
{
|
||||
removed[removedCount] = item;
|
||||
++removedCount;
|
||||
}
|
||||
}
|
||||
|
||||
if (addedCount + removedCount >= value.Count())
|
||||
{
|
||||
writer.WriteByteSafe(1);
|
||||
writer.WriteValueSafe(value);
|
||||
return;
|
||||
}
|
||||
|
||||
writer.WriteByteSafe(0);
|
||||
writer.WriteValueSafe(addedCount);
|
||||
for (var i = 0; i < addedCount; ++i)
|
||||
{
|
||||
NetworkVariableSerialization<T>.Write(writer, ref added[i]);
|
||||
}
|
||||
writer.WriteValueSafe(removedCount);
|
||||
for (var i = 0; i < removedCount; ++i)
|
||||
{
|
||||
NetworkVariableSerialization<T>.Write(writer, ref removed[i]);
|
||||
}
|
||||
}
|
||||
|
||||
public static void ReadNativeHashSetDelta<T>(FastBufferReader reader, ref NativeHashSet<T> value) where T : unmanaged, IEquatable<T>
|
||||
{
|
||||
// See ReadHashSet; this is the same algorithm, adjusted for the NativeHashSet API
|
||||
reader.ReadByteSafe(out byte full);
|
||||
if (full != 0)
|
||||
{
|
||||
reader.ReadValueSafeInPlace(ref value);
|
||||
return;
|
||||
}
|
||||
reader.ReadValueSafe(out int addedCount);
|
||||
for (var i = 0; i < addedCount; ++i)
|
||||
{
|
||||
T item = default;
|
||||
NetworkVariableSerialization<T>.Read(reader, ref item);
|
||||
value.Add(item);
|
||||
}
|
||||
reader.ReadValueSafe(out int removedCount);
|
||||
for (var i = 0; i < removedCount; ++i)
|
||||
{
|
||||
T item = default;
|
||||
NetworkVariableSerialization<T>.Read(reader, ref item);
|
||||
value.Remove(item);
|
||||
}
|
||||
}
|
||||
|
||||
public static unsafe void WriteNativeHashMapDelta<TKey, TVal>(FastBufferWriter writer, ref NativeHashMap<TKey, TVal> value, ref NativeHashMap<TKey, TVal> previousValue)
|
||||
where TKey : unmanaged, IEquatable<TKey>
|
||||
where TVal : unmanaged
|
||||
{
|
||||
// See WriteDictionary; this is the same algorithm, adjusted for the NativeHashMap API
|
||||
var added = stackalloc KeyValue<TKey, TVal>[value.Count()];
|
||||
var changed = stackalloc KeyValue<TKey, TVal>[value.Count()];
|
||||
var removed = stackalloc KeyValue<TKey, TVal>[previousValue.Count()];
|
||||
var addedCount = 0;
|
||||
var changedCount = 0;
|
||||
var removedCount = 0;
|
||||
foreach (var item in value)
|
||||
{
|
||||
var hasPrevVal = previousValue.TryGetValue(item.Key, out var prevVal);
|
||||
if (!hasPrevVal)
|
||||
{
|
||||
added[addedCount] = item;
|
||||
++addedCount;
|
||||
}
|
||||
else if (!NetworkVariableSerialization<TVal>.AreEqual(ref item.Value, ref prevVal))
|
||||
{
|
||||
changed[changedCount] = item;
|
||||
++changedCount;
|
||||
}
|
||||
}
|
||||
|
||||
foreach (var item in previousValue)
|
||||
{
|
||||
if (!value.ContainsKey(item.Key))
|
||||
{
|
||||
removed[removedCount] = item;
|
||||
++removedCount;
|
||||
}
|
||||
}
|
||||
|
||||
if (addedCount + removedCount + changedCount >= value.Count())
|
||||
{
|
||||
writer.WriteByteSafe(1);
|
||||
writer.WriteValueSafe(value);
|
||||
return;
|
||||
}
|
||||
|
||||
writer.WriteByteSafe(0);
|
||||
writer.WriteValueSafe(addedCount);
|
||||
for (var i = 0; i < addedCount; ++i)
|
||||
{
|
||||
(var key, var val) = (added[i].Key, added[i].Value);
|
||||
NetworkVariableSerialization<TKey>.Write(writer, ref key);
|
||||
NetworkVariableSerialization<TVal>.Write(writer, ref val);
|
||||
}
|
||||
writer.WriteValueSafe(removedCount);
|
||||
for (var i = 0; i < removedCount; ++i)
|
||||
{
|
||||
var key = removed[i].Key;
|
||||
NetworkVariableSerialization<TKey>.Write(writer, ref key);
|
||||
}
|
||||
writer.WriteValueSafe(changedCount);
|
||||
for (var i = 0; i < changedCount; ++i)
|
||||
{
|
||||
(var key, var val) = (changed[i].Key, changed[i].Value);
|
||||
NetworkVariableSerialization<TKey>.Write(writer, ref key);
|
||||
NetworkVariableSerialization<TVal>.Write(writer, ref val);
|
||||
}
|
||||
}
|
||||
|
||||
public static void ReadNativeHashMapDelta<TKey, TVal>(FastBufferReader reader, ref NativeHashMap<TKey, TVal> value)
|
||||
where TKey : unmanaged, IEquatable<TKey>
|
||||
where TVal : unmanaged
|
||||
{
|
||||
// See ReadDictionary; this is the same algorithm, adjusted for the NativeHashMap API
|
||||
reader.ReadByteSafe(out byte full);
|
||||
if (full != 0)
|
||||
{
|
||||
reader.ReadValueSafeInPlace(ref value);
|
||||
return;
|
||||
}
|
||||
// Added
|
||||
reader.ReadValueSafe(out int length);
|
||||
for (var i = 0; i < length; ++i)
|
||||
{
|
||||
(TKey key, TVal val) = (default, default);
|
||||
NetworkVariableSerialization<TKey>.Read(reader, ref key);
|
||||
NetworkVariableSerialization<TVal>.Read(reader, ref val);
|
||||
value.Add(key, val);
|
||||
}
|
||||
// Removed
|
||||
reader.ReadValueSafe(out length);
|
||||
for (var i = 0; i < length; ++i)
|
||||
{
|
||||
TKey key = default;
|
||||
NetworkVariableSerialization<TKey>.Read(reader, ref key);
|
||||
value.Remove(key);
|
||||
}
|
||||
// Changed
|
||||
reader.ReadValueSafe(out length);
|
||||
for (var i = 0; i < length; ++i)
|
||||
{
|
||||
(TKey key, TVal val) = (default, default);
|
||||
NetworkVariableSerialization<TKey>.Read(reader, ref key);
|
||||
NetworkVariableSerialization<TVal>.Read(reader, ref val);
|
||||
value[key] = val;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: c822ece4e24f4676861e07288a7f8526
|
||||
timeCreated: 1705437250
|
||||
@@ -22,6 +22,28 @@ namespace Unity.Netcode
|
||||
/// </summary>
|
||||
public OnValueChangedDelegate OnValueChanged;
|
||||
|
||||
public delegate bool CheckExceedsDirtinessThresholdDelegate(in T previousValue, in T newValue);
|
||||
|
||||
public CheckExceedsDirtinessThresholdDelegate CheckExceedsDirtinessThreshold;
|
||||
|
||||
public override bool ExceedsDirtinessThreshold()
|
||||
{
|
||||
if (CheckExceedsDirtinessThreshold != null && m_HasPreviousValue)
|
||||
{
|
||||
return CheckExceedsDirtinessThreshold(m_PreviousValue, m_InternalValue);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
public override void OnInitialize()
|
||||
{
|
||||
base.OnInitialize();
|
||||
|
||||
m_HasPreviousValue = true;
|
||||
NetworkVariableSerialization<T>.Duplicate(m_InternalValue, ref m_PreviousValue);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Constructor for <see cref="NetworkVariable{T}"/>
|
||||
/// </summary>
|
||||
@@ -142,16 +164,16 @@ namespace Unity.Netcode
|
||||
/// </summary>
|
||||
public override void ResetDirty()
|
||||
{
|
||||
base.ResetDirty();
|
||||
// Resetting the dirty value declares that the current value is not dirty
|
||||
// Therefore, we set the m_PreviousValue field to a duplicate of the current
|
||||
// field, so that our next dirty check is made against the current "not dirty"
|
||||
// value.
|
||||
if (!m_HasPreviousValue || !NetworkVariableSerialization<T>.AreEqual(ref m_InternalValue, ref m_PreviousValue))
|
||||
if (IsDirty())
|
||||
{
|
||||
m_HasPreviousValue = true;
|
||||
NetworkVariableSerialization<T>.Duplicate(m_InternalValue, ref m_PreviousValue);
|
||||
}
|
||||
base.ResetDirty();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -173,7 +195,7 @@ namespace Unity.Netcode
|
||||
/// <param name="writer">The stream to write the value to</param>
|
||||
public override void WriteDelta(FastBufferWriter writer)
|
||||
{
|
||||
WriteField(writer);
|
||||
NetworkVariableSerialization<T>.WriteDelta(writer, ref m_InternalValue, ref m_PreviousValue);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -189,7 +211,7 @@ namespace Unity.Netcode
|
||||
// would be stored in different fields
|
||||
|
||||
T previousValue = m_InternalValue;
|
||||
NetworkVariableSerialization<T>.Read(reader, ref m_InternalValue);
|
||||
NetworkVariableSerialization<T>.ReadDelta(reader, ref m_InternalValue);
|
||||
|
||||
if (keepDirtyDelta)
|
||||
{
|
||||
|
||||
@@ -3,11 +3,26 @@ using UnityEngine;
|
||||
|
||||
namespace Unity.Netcode
|
||||
{
|
||||
public struct NetworkVariableUpdateTraits
|
||||
{
|
||||
[Tooltip("The minimum amount of time that must pass between sending updates. If this amount of time has not passed since the last update, dirtiness will be ignored.")]
|
||||
public float MinSecondsBetweenUpdates;
|
||||
|
||||
[Tooltip("The maximum amount of time that a variable can be dirty without sending an update. If this amount of time has passed since the last update, an update will be sent even if the dirtiness threshold has not been met.")]
|
||||
public float MaxSecondsBetweenUpdates;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Interface for network value containers
|
||||
/// </summary>
|
||||
public abstract class NetworkVariableBase : IDisposable
|
||||
{
|
||||
[SerializeField]
|
||||
internal NetworkVariableUpdateTraits UpdateTraits = default;
|
||||
|
||||
[NonSerialized]
|
||||
internal double LastUpdateSent;
|
||||
|
||||
/// <summary>
|
||||
/// The delivery type (QoS) to send data with
|
||||
/// </summary>
|
||||
@@ -30,6 +45,43 @@ namespace Unity.Netcode
|
||||
public void Initialize(NetworkBehaviour networkBehaviour)
|
||||
{
|
||||
m_NetworkBehaviour = networkBehaviour;
|
||||
if (m_NetworkBehaviour.NetworkManager)
|
||||
{
|
||||
if (m_NetworkBehaviour.NetworkManager.NetworkTimeSystem != null)
|
||||
{
|
||||
UpdateLastSentTime();
|
||||
}
|
||||
}
|
||||
|
||||
OnInitialize();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Called on initialization
|
||||
/// </summary>
|
||||
public virtual void OnInitialize()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Sets the update traits for this network variable to determine how frequently it will send updates.
|
||||
/// </summary>
|
||||
/// <param name="traits"></param>
|
||||
public void SetUpdateTraits(NetworkVariableUpdateTraits traits)
|
||||
{
|
||||
UpdateTraits = traits;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Check whether or not this variable has changed significantly enough to send an update.
|
||||
/// If not, no update will be sent even if the variable is dirty, unless the time since last update exceeds
|
||||
/// the <see cref="UpdateTraits"/>' <see cref="NetworkVariableUpdateTraits.MaxSecondsBetweenUpdates"/>.
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
public virtual bool ExceedsDirtinessThreshold()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -92,6 +144,25 @@ namespace Unity.Netcode
|
||||
}
|
||||
}
|
||||
|
||||
internal bool CanSend()
|
||||
{
|
||||
var timeSinceLastUpdate = m_NetworkBehaviour.NetworkManager.NetworkTimeSystem.LocalTime - LastUpdateSent;
|
||||
return
|
||||
(
|
||||
UpdateTraits.MaxSecondsBetweenUpdates > 0 &&
|
||||
timeSinceLastUpdate >= UpdateTraits.MaxSecondsBetweenUpdates
|
||||
) ||
|
||||
(
|
||||
timeSinceLastUpdate >= UpdateTraits.MinSecondsBetweenUpdates &&
|
||||
ExceedsDirtinessThreshold()
|
||||
);
|
||||
}
|
||||
|
||||
internal void UpdateLastSentTime()
|
||||
{
|
||||
LastUpdateSent = m_NetworkBehaviour.NetworkManager.NetworkTimeSystem.LocalTime;
|
||||
}
|
||||
|
||||
protected void MarkNetworkBehaviourDirty()
|
||||
{
|
||||
if (m_NetworkBehaviour == null)
|
||||
@@ -100,7 +171,25 @@ namespace Unity.Netcode
|
||||
"Are you modifying a NetworkVariable before the NetworkObject is spawned?");
|
||||
return;
|
||||
}
|
||||
if (m_NetworkBehaviour.NetworkManager.ShutdownInProgress)
|
||||
{
|
||||
if (m_NetworkBehaviour.NetworkManager.LogLevel <= LogLevel.Developer)
|
||||
{
|
||||
Debug.LogWarning($"NetworkVariable is written to during the NetworkManager shutdown! " +
|
||||
"Are you modifying a NetworkVariable within a NetworkBehaviour.OnDestroy or NetworkBehaviour.OnDespawn method?");
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (!m_NetworkBehaviour.NetworkManager.IsListening)
|
||||
{
|
||||
if (m_NetworkBehaviour.NetworkManager.LogLevel <= LogLevel.Developer)
|
||||
{
|
||||
Debug.LogWarning($"NetworkVariable is written to after the NetworkManager has already shutdown! " +
|
||||
"Are you modifying a NetworkVariable within a NetworkBehaviour.OnDestroy or NetworkBehaviour.OnDespawn method?");
|
||||
}
|
||||
return;
|
||||
}
|
||||
m_NetworkBehaviour.NetworkManager.BehaviourUpdater.AddForUpdate(m_NetworkBehaviour.NetworkObject);
|
||||
}
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
107
Runtime/NetworkVariable/ResizableBitVector.cs
Normal file
107
Runtime/NetworkVariable/ResizableBitVector.cs
Normal file
@@ -0,0 +1,107 @@
|
||||
using System;
|
||||
using Unity.Collections;
|
||||
using Unity.Collections.LowLevel.Unsafe;
|
||||
|
||||
namespace Unity.Netcode
|
||||
{
|
||||
/// <summary>
|
||||
/// This is a simple resizable bit vector - i.e., a list of flags that use 1 bit each and can
|
||||
/// grow to an indefinite size. This is backed by a NativeList<byte> instead of a single
|
||||
/// integer value, allowing it to contain any size of memory. Contains built-in serialization support.
|
||||
/// </summary>
|
||||
internal struct ResizableBitVector : INetworkSerializable, IDisposable
|
||||
{
|
||||
private NativeList<byte> m_Bits;
|
||||
private const int k_Divisor = sizeof(byte) * 8;
|
||||
|
||||
public ResizableBitVector(Allocator allocator)
|
||||
{
|
||||
m_Bits = new NativeList<byte>(allocator);
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
m_Bits.Dispose();
|
||||
}
|
||||
|
||||
public int GetSerializedSize()
|
||||
{
|
||||
return sizeof(int) + m_Bits.Length;
|
||||
}
|
||||
|
||||
private (int, int) GetBitData(int i)
|
||||
{
|
||||
var index = i / k_Divisor;
|
||||
var bitWithinIndex = i % k_Divisor;
|
||||
return (index, bitWithinIndex);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Set bit 'i' - i.e., bit 0 is 00000001, bit 1 is 00000010, and so on.
|
||||
/// There is no upper bound on i except for the memory available in the system.
|
||||
/// </summary>
|
||||
/// <param name="i"></param>
|
||||
public void Set(int i)
|
||||
{
|
||||
var (index, bitWithinIndex) = GetBitData(i);
|
||||
if (index >= m_Bits.Length)
|
||||
{
|
||||
m_Bits.Resize(index + 1, NativeArrayOptions.ClearMemory);
|
||||
}
|
||||
|
||||
m_Bits[index] |= (byte)(1 << bitWithinIndex);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Unset bit 'i' - i.e., bit 0 is 00000001, bit 1 is 00000010, and so on.
|
||||
/// There is no upper bound on i except for the memory available in the system.
|
||||
/// Note that once a BitVector has grown to a certain size, it will not shrink back down,
|
||||
/// so if you set and unset every bit, it will still serialize at its high watermark size.
|
||||
/// </summary>
|
||||
/// <param name="i"></param>
|
||||
public void Unset(int i)
|
||||
{
|
||||
var (index, bitWithinIndex) = GetBitData(i);
|
||||
if (index >= m_Bits.Length)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
m_Bits[index] &= (byte)~(1 << bitWithinIndex);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Check if bit 'i' is set - i.e., bit 0 is 00000001, bit 1 is 00000010, and so on.
|
||||
/// There is no upper bound on i except for the memory available in the system.
|
||||
/// </summary>
|
||||
/// <param name="i"></param>
|
||||
public bool IsSet(int i)
|
||||
{
|
||||
var (index, bitWithinIndex) = GetBitData(i);
|
||||
if (index >= m_Bits.Length)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return (m_Bits[index] & (byte)(1 << bitWithinIndex)) != 0;
|
||||
}
|
||||
|
||||
public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
|
||||
{
|
||||
var length = m_Bits.Length;
|
||||
serializer.SerializeValue(ref length);
|
||||
m_Bits.ResizeUninitialized(length);
|
||||
var ptr = m_Bits.GetUnsafePtr();
|
||||
{
|
||||
if (serializer.IsReader)
|
||||
{
|
||||
serializer.GetFastBufferReader().ReadBytesSafe((byte*)ptr, length);
|
||||
}
|
||||
else
|
||||
{
|
||||
serializer.GetFastBufferWriter().WriteBytesSafe((byte*)ptr, length);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
3
Runtime/NetworkVariable/ResizableBitVector.cs.meta
Normal file
3
Runtime/NetworkVariable/ResizableBitVector.cs.meta
Normal file
@@ -0,0 +1,3 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 664696a622e244dfa43b26628c05e4a6
|
||||
timeCreated: 1705437231
|
||||
@@ -1,6 +1,7 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Unity.Collections;
|
||||
using UnityEngine;
|
||||
using UnityEngine.SceneManagement;
|
||||
|
||||
@@ -597,6 +598,47 @@ namespace Unity.Netcode
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Used for integration tests, normal runtime mode this will always be LoadSceneMode.Single
|
||||
/// </summary>
|
||||
internal LoadSceneMode DeferLoadingFilter = LoadSceneMode.Single;
|
||||
/// <summary>
|
||||
/// Determines if a remote client should defer object creation initiated by CreateObjectMessage
|
||||
/// until a scene event is completed.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Deferring object creation should only occur when there is a possibility the objects could be
|
||||
/// instantiated in a currently active scene that will be unloaded during single mode scene loading
|
||||
/// to prevent the newly created objects from being destroyed when the scene is unloaded.
|
||||
/// </remarks>
|
||||
internal bool ShouldDeferCreateObject()
|
||||
{
|
||||
// This applies only to remote clients and when scene management is enabled
|
||||
if (!NetworkManager.NetworkConfig.EnableSceneManagement || NetworkManager.IsServer)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
var synchronizeEventDetected = false;
|
||||
var loadingEventDetected = false;
|
||||
foreach (var entry in SceneEventDataStore)
|
||||
{
|
||||
if (entry.Value.SceneEventType == SceneEventType.Synchronize)
|
||||
{
|
||||
synchronizeEventDetected = true;
|
||||
}
|
||||
|
||||
// When loading a scene and the load scene mode is single we should defer object creation
|
||||
if (entry.Value.SceneEventType == SceneEventType.Load && entry.Value.LoadSceneMode == DeferLoadingFilter)
|
||||
{
|
||||
loadingEventDetected = true;
|
||||
}
|
||||
}
|
||||
|
||||
// Synchronizing while in client synchronization mode single --> Defer
|
||||
// When not synchronizing but loading a scene in single mode --> Defer
|
||||
return (synchronizeEventDetected && ClientSynchronizationMode == LoadSceneMode.Single) || (!synchronizeEventDetected && loadingEventDetected);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the scene name from full path to the scene
|
||||
/// </summary>
|
||||
@@ -740,12 +782,17 @@ namespace Unity.Netcode
|
||||
// Since NetworkManager is now always migrated to the DDOL we will use this to get the DDOL scene
|
||||
DontDestroyOnLoadScene = networkManager.gameObject.scene;
|
||||
|
||||
// Since the server tracks loaded scenes, we need to add the currently active scene
|
||||
// to the list of scenes that can be unloaded.
|
||||
if (networkManager.IsServer)
|
||||
// Since the server tracks loaded scenes, we need to add any currently loaded scenes on the
|
||||
// server side when the NetworkManager is started and NetworkSceneManager instantiated when
|
||||
// scene management is enabled.
|
||||
if (networkManager.IsServer && networkManager.NetworkConfig.EnableSceneManagement)
|
||||
{
|
||||
var activeScene = SceneManager.GetActiveScene();
|
||||
ScenesLoaded.Add(activeScene.handle, activeScene);
|
||||
for (int i = 0; i < SceneManager.sceneCount; i++)
|
||||
{
|
||||
var loadedScene = SceneManager.GetSceneAt(i);
|
||||
ScenesLoaded.Add(loadedScene.handle, loadedScene);
|
||||
}
|
||||
SceneManagerHandler.PopulateLoadedScenes(ref ScenesLoaded, NetworkManager);
|
||||
}
|
||||
|
||||
// Add to the server to client scene handle table
|
||||
@@ -969,17 +1016,16 @@ namespace Unity.Netcode
|
||||
/// <returns></returns>
|
||||
private SceneEventProgress ValidateSceneEventUnloading(Scene scene)
|
||||
{
|
||||
if (!NetworkManager.IsServer)
|
||||
{
|
||||
throw new NotServerException("Only server can start a scene event!");
|
||||
}
|
||||
|
||||
if (!NetworkManager.NetworkConfig.EnableSceneManagement)
|
||||
{
|
||||
//Log message about enabling SceneManagement
|
||||
throw new Exception(
|
||||
$"{nameof(NetworkConfig.EnableSceneManagement)} flag is not enabled in the {nameof(Netcode.NetworkManager)}'s {nameof(NetworkConfig)}. " +
|
||||
$"Please set {nameof(NetworkConfig.EnableSceneManagement)} flag to true before calling {nameof(LoadScene)} or {nameof(UnloadScene)}.");
|
||||
Debug.LogWarning($"{nameof(LoadScene)} was called, but {nameof(NetworkConfig.EnableSceneManagement)} was not enabled! Enable {nameof(NetworkConfig.EnableSceneManagement)} prior to starting a client, host, or server prior to using {nameof(NetworkSceneManager)}!");
|
||||
return new SceneEventProgress(null, SceneEventProgressStatus.SceneManagementNotEnabled);
|
||||
}
|
||||
|
||||
if (!NetworkManager.IsServer)
|
||||
{
|
||||
Debug.LogWarning($"[{nameof(SceneEventProgressStatus.ServerOnlyAction)}][Unload] Clients cannot invoke the {nameof(UnloadScene)} method!");
|
||||
return new SceneEventProgress(null, SceneEventProgressStatus.ServerOnlyAction);
|
||||
}
|
||||
|
||||
if (!scene.isLoaded)
|
||||
@@ -998,16 +1044,16 @@ namespace Unity.Netcode
|
||||
/// <returns></returns>
|
||||
private SceneEventProgress ValidateSceneEventLoading(string sceneName)
|
||||
{
|
||||
if (!NetworkManager.IsServer)
|
||||
{
|
||||
throw new NotServerException("Only server can start a scene event!");
|
||||
}
|
||||
if (!NetworkManager.NetworkConfig.EnableSceneManagement)
|
||||
{
|
||||
//Log message about enabling SceneManagement
|
||||
throw new Exception(
|
||||
$"{nameof(NetworkConfig.EnableSceneManagement)} flag is not enabled in the {nameof(Netcode.NetworkManager)}'s {nameof(NetworkConfig)}. " +
|
||||
$"Please set {nameof(NetworkConfig.EnableSceneManagement)} flag to true before calling {nameof(LoadScene)} or {nameof(UnloadScene)}.");
|
||||
Debug.LogWarning($"{nameof(LoadScene)} was called, but {nameof(NetworkConfig.EnableSceneManagement)} was not enabled! Enable {nameof(NetworkConfig.EnableSceneManagement)} prior to starting a client, host, or server prior to using {nameof(NetworkSceneManager)}!");
|
||||
return new SceneEventProgress(null, SceneEventProgressStatus.SceneManagementNotEnabled);
|
||||
}
|
||||
|
||||
if (!NetworkManager.IsServer)
|
||||
{
|
||||
Debug.LogWarning($"[{nameof(SceneEventProgressStatus.ServerOnlyAction)}][Load] Clients cannot invoke the {nameof(LoadScene)} method!");
|
||||
return new SceneEventProgress(null, SceneEventProgressStatus.ServerOnlyAction);
|
||||
}
|
||||
|
||||
return ValidateSceneEvent(sceneName);
|
||||
@@ -1112,6 +1158,7 @@ namespace Unity.Netcode
|
||||
{
|
||||
var sceneName = scene.name;
|
||||
var sceneHandle = scene.handle;
|
||||
|
||||
if (!scene.isLoaded)
|
||||
{
|
||||
Debug.LogWarning($"{nameof(UnloadScene)} was called, but the scene {scene.name} is not currently loaded!");
|
||||
@@ -1697,6 +1744,9 @@ namespace Unity.Netcode
|
||||
SendSceneEventData(sceneEventId, new ulong[] { NetworkManager.ServerClientId });
|
||||
m_IsSceneEventActive = false;
|
||||
|
||||
// Process any pending create object messages that the client received while loading a scene
|
||||
ProcessDeferredCreateObjectMessages();
|
||||
|
||||
// Notify local client that the scene was loaded
|
||||
OnSceneEvent?.Invoke(new SceneEvent()
|
||||
{
|
||||
@@ -2058,6 +2108,9 @@ namespace Unity.Netcode
|
||||
// If needed, migrate dynamically spawned NetworkObjects to the same scene as they are on the server
|
||||
SynchronizeNetworkObjectScene();
|
||||
|
||||
// Process any pending create object messages that the client received during synchronization
|
||||
ProcessDeferredCreateObjectMessages();
|
||||
|
||||
sceneEventData.SceneEventType = SceneEventType.SynchronizeComplete;
|
||||
SendSceneEventData(sceneEventId, new ulong[] { NetworkManager.ServerClientId });
|
||||
|
||||
@@ -2213,6 +2266,11 @@ namespace Unity.Netcode
|
||||
// of the client was persisted since MLAPI)
|
||||
NetworkManager.ConnectionManager.InvokeOnClientConnectedCallback(clientId);
|
||||
|
||||
if (NetworkManager.IsHost)
|
||||
{
|
||||
NetworkManager.ConnectionManager.InvokeOnPeerConnectedCallback(clientId);
|
||||
}
|
||||
|
||||
// Check to see if the client needs to resynchronize and before sending the message make sure the client is still connected to avoid
|
||||
// a potential crash within the MessageSystem (i.e. sending to a client that no longer exists)
|
||||
if (sceneEventData.ClientNeedsReSynchronization() && !DisableReSynchronization && NetworkManager.ConnectedClients.ContainsKey(clientId))
|
||||
@@ -2549,5 +2607,50 @@ namespace Unity.Netcode
|
||||
internal Dictionary<int, List<ulong>> ObjectsMigratedTable;
|
||||
}
|
||||
internal List<DeferredObjectsMovedEvent> DeferredObjectsMovedEvents = new List<DeferredObjectsMovedEvent>();
|
||||
|
||||
internal struct DeferredObjectCreation
|
||||
{
|
||||
internal ulong SenderId;
|
||||
internal uint MessageSize;
|
||||
internal NetworkObject.SceneObject SceneObject;
|
||||
internal FastBufferReader FastBufferReader;
|
||||
}
|
||||
|
||||
internal List<DeferredObjectCreation> DeferredObjectCreationList = new List<DeferredObjectCreation>();
|
||||
internal int DeferredObjectCreationCount;
|
||||
|
||||
internal void DeferCreateObject(ulong senderId, uint messageSize, NetworkObject.SceneObject sceneObject, FastBufferReader fastBufferReader)
|
||||
{
|
||||
var deferredObjectCreationEntry = new DeferredObjectCreation()
|
||||
{
|
||||
SenderId = senderId,
|
||||
MessageSize = messageSize,
|
||||
SceneObject = sceneObject,
|
||||
};
|
||||
|
||||
unsafe
|
||||
{
|
||||
deferredObjectCreationEntry.FastBufferReader = new FastBufferReader(fastBufferReader.GetUnsafePtrAtCurrentPosition(), Allocator.Persistent, fastBufferReader.Length - fastBufferReader.Position);
|
||||
}
|
||||
|
||||
DeferredObjectCreationList.Add(deferredObjectCreationEntry);
|
||||
}
|
||||
|
||||
private void ProcessDeferredCreateObjectMessages()
|
||||
{
|
||||
// If no pending create object messages exit early
|
||||
if (DeferredObjectCreationList.Count == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
var networkManager = NetworkManager;
|
||||
// Process all deferred create object messages.
|
||||
foreach (var deferredObjectCreation in DeferredObjectCreationList)
|
||||
{
|
||||
CreateObjectMessage.CreateObject(ref networkManager, deferredObjectCreation.SenderId, deferredObjectCreation.MessageSize, deferredObjectCreation.SceneObject, deferredObjectCreation.FastBufferReader);
|
||||
}
|
||||
DeferredObjectCreationCount = DeferredObjectCreationList.Count;
|
||||
DeferredObjectCreationList.Clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -245,6 +245,73 @@ namespace Unity.Netcode
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Used with SortParentedNetworkObjects to sort the children of the root parent NetworkObject
|
||||
/// </summary>
|
||||
/// <param name="first">object to be sorted</param>
|
||||
/// <param name="second">object to be compared to for sorting the first object</param>
|
||||
/// <returns></returns>
|
||||
private int SortChildrenNetworkObjects(NetworkObject first, NetworkObject second)
|
||||
{
|
||||
var firstParent = first.GetCachedParent()?.GetComponent<NetworkObject>();
|
||||
// If the second is the first's parent then move the first down
|
||||
if (firstParent != null && firstParent == second)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
var secondParent = second.GetCachedParent()?.GetComponent<NetworkObject>();
|
||||
// If the first is the second's parent then move the first up
|
||||
if (secondParent != null && secondParent == first)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Otherwise, don't move the first at all
|
||||
return 0;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Sorts the synchronization order of the NetworkObjects to be serialized
|
||||
/// by parents before children order
|
||||
/// </summary>
|
||||
private void SortParentedNetworkObjects()
|
||||
{
|
||||
var networkObjectList = m_NetworkObjectsSync.ToList();
|
||||
foreach (var networkObject in networkObjectList)
|
||||
{
|
||||
// Find only the root parent NetworkObjects
|
||||
if (networkObject.transform.childCount > 0 && networkObject.transform.parent == null)
|
||||
{
|
||||
// Get all child NetworkObjects of the root
|
||||
var childNetworkObjects = networkObject.GetComponentsInChildren<NetworkObject>().ToList();
|
||||
|
||||
childNetworkObjects.Sort(SortChildrenNetworkObjects);
|
||||
|
||||
// Remove the root from the children list
|
||||
childNetworkObjects.Remove(networkObject);
|
||||
|
||||
// Remove the root's children from the primary list
|
||||
foreach (var childObject in childNetworkObjects)
|
||||
{
|
||||
m_NetworkObjectsSync.Remove(childObject);
|
||||
}
|
||||
// Insert or Add the sorted children list
|
||||
var nextIndex = m_NetworkObjectsSync.IndexOf(networkObject) + 1;
|
||||
if (nextIndex == m_NetworkObjectsSync.Count)
|
||||
{
|
||||
m_NetworkObjectsSync.AddRange(childNetworkObjects);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_NetworkObjectsSync.InsertRange(nextIndex, childNetworkObjects);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
internal static bool LogSerializationOrder = false;
|
||||
|
||||
internal void AddSpawnedNetworkObjects()
|
||||
{
|
||||
m_NetworkObjectsSync.Clear();
|
||||
@@ -256,22 +323,22 @@ namespace Unity.Netcode
|
||||
}
|
||||
}
|
||||
|
||||
// Sort by parents before children
|
||||
m_NetworkObjectsSync.Sort(SortParentedNetworkObjects);
|
||||
|
||||
// Sort by INetworkPrefabInstanceHandler implementation before the
|
||||
// NetworkObjects spawned by the implementation
|
||||
m_NetworkObjectsSync.Sort(SortNetworkObjects);
|
||||
|
||||
// The last thing we sort is parents before children
|
||||
SortParentedNetworkObjects();
|
||||
|
||||
// This is useful to know what NetworkObjects a client is going to be synchronized with
|
||||
// as well as the order in which they will be deserialized
|
||||
if (m_NetworkManager.LogLevel == LogLevel.Developer)
|
||||
if (LogSerializationOrder && m_NetworkManager.LogLevel == LogLevel.Developer)
|
||||
{
|
||||
var messageBuilder = new System.Text.StringBuilder(0xFFFF);
|
||||
messageBuilder.Append("[Server-Side Client-Synchronization] NetworkObject serialization order:");
|
||||
messageBuilder.AppendLine("[Server-Side Client-Synchronization] NetworkObject serialization order:");
|
||||
foreach (var networkObject in m_NetworkObjectsSync)
|
||||
{
|
||||
messageBuilder.Append($"{networkObject.name}");
|
||||
messageBuilder.AppendLine($"{networkObject.name}");
|
||||
}
|
||||
NetworkLog.LogInfo(messageBuilder.ToString());
|
||||
}
|
||||
@@ -362,32 +429,6 @@ namespace Unity.Netcode
|
||||
return 0;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Sorts the synchronization order of the NetworkObjects to be serialized
|
||||
/// by parents before children.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// This only handles late joining players. Spawning and nesting several children
|
||||
/// dynamically is still handled by the orphaned child list when deserialized out of
|
||||
/// hierarchical order (i.e. Spawn parent and child dynamically, parent message is
|
||||
/// dropped and re-sent but child object is received and processed)
|
||||
/// </remarks>
|
||||
private int SortParentedNetworkObjects(NetworkObject first, NetworkObject second)
|
||||
{
|
||||
// If the first has a parent, move the first down
|
||||
if (first.transform.parent != null)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
else // If the second has a parent and the first does not, then move the first up
|
||||
if (second.transform.parent != null)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Client and Server Side:
|
||||
/// Serializes data based on the SceneEvent type (<see cref="SceneEventType"/>)
|
||||
|
||||
@@ -47,6 +47,14 @@ namespace Unity.Netcode
|
||||
/// If you receive this event then it is most likely due to a bug (<em>please open a GitHub issue with steps to replicate</em>).<br/>
|
||||
/// </summary>
|
||||
InternalNetcodeError,
|
||||
/// <summary>
|
||||
/// This is returned when an unload or load action is attempted and scene management is disabled
|
||||
/// </summary>
|
||||
SceneManagementNotEnabled,
|
||||
/// <summary>
|
||||
/// This is returned when a client attempts to perform a server only action
|
||||
/// </summary>
|
||||
ServerOnlyAction,
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
||||
@@ -1069,6 +1069,36 @@ namespace Unity.Netcode
|
||||
ReadUnmanagedSafeInPlace(ref value);
|
||||
}
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
internal void ReadValueSafeInPlace<T>(ref NativeHashSet<T> value) where T : unmanaged, IEquatable<T>
|
||||
{
|
||||
ReadUnmanagedSafe(out int length);
|
||||
value.Clear();
|
||||
for (var i = 0; i < length; ++i)
|
||||
{
|
||||
T val = default;
|
||||
NetworkVariableSerialization<T>.Read(this, ref val);
|
||||
value.Add(val);
|
||||
}
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
internal void ReadValueSafeInPlace<TKey, TVal>(ref NativeHashMap<TKey, TVal> value)
|
||||
where TKey : unmanaged, IEquatable<TKey>
|
||||
where TVal : unmanaged
|
||||
{
|
||||
ReadUnmanagedSafe(out int length);
|
||||
value.Clear();
|
||||
for (var i = 0; i < length; ++i)
|
||||
{
|
||||
TKey key = default;
|
||||
TVal val = default;
|
||||
NetworkVariableSerialization<TKey>.Read(this, ref key);
|
||||
NetworkVariableSerialization<TVal>.Read(this, ref val);
|
||||
value[key] = val;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/// <summary>
|
||||
|
||||
@@ -1189,6 +1189,31 @@ namespace Unity.Netcode
|
||||
WriteUnmanaged(value);
|
||||
}
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
internal void WriteValueSafe<T>(NativeHashSet<T> value) where T : unmanaged, IEquatable<T>
|
||||
{
|
||||
WriteUnmanagedSafe(value.Count());
|
||||
foreach (var item in value)
|
||||
{
|
||||
var iReffable = item;
|
||||
NetworkVariableSerialization<T>.Write(this, ref iReffable);
|
||||
}
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
internal void WriteValueSafe<TKey, TVal>(NativeHashMap<TKey, TVal> value)
|
||||
where TKey : unmanaged, IEquatable<TKey>
|
||||
where TVal : unmanaged
|
||||
{
|
||||
WriteUnmanagedSafe(value.Count());
|
||||
foreach (var item in value)
|
||||
{
|
||||
(var key, var val) = (item.Key, item.Value);
|
||||
NetworkVariableSerialization<TKey>.Write(this, ref key);
|
||||
NetworkVariableSerialization<TVal>.Write(this, ref val);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/// <summary>
|
||||
|
||||
@@ -11,6 +11,7 @@ namespace Unity.Netcode
|
||||
{
|
||||
private NetworkObjectReference m_NetworkObjectReference;
|
||||
private ushort m_NetworkBehaviourId;
|
||||
private static ushort s_NullId = ushort.MaxValue;
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new instance of the <see cref="NetworkBehaviourReference{T}"/> struct.
|
||||
@@ -21,7 +22,9 @@ namespace Unity.Netcode
|
||||
{
|
||||
if (networkBehaviour == null)
|
||||
{
|
||||
throw new ArgumentNullException(nameof(networkBehaviour));
|
||||
m_NetworkObjectReference = new NetworkObjectReference((NetworkObject)null);
|
||||
m_NetworkBehaviourId = s_NullId;
|
||||
return;
|
||||
}
|
||||
if (networkBehaviour.NetworkObject == null)
|
||||
{
|
||||
@@ -60,6 +63,10 @@ namespace Unity.Netcode
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
private static NetworkBehaviour GetInternal(NetworkBehaviourReference networkBehaviourRef, NetworkManager networkManager = null)
|
||||
{
|
||||
if (networkBehaviourRef.m_NetworkBehaviourId == s_NullId)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
if (networkBehaviourRef.m_NetworkObjectReference.TryGet(out NetworkObject networkObject, networkManager))
|
||||
{
|
||||
return networkObject.GetNetworkBehaviourAtOrderIndex(networkBehaviourRef.m_NetworkBehaviourId);
|
||||
|
||||
@@ -10,6 +10,7 @@ namespace Unity.Netcode
|
||||
public struct NetworkObjectReference : INetworkSerializable, IEquatable<NetworkObjectReference>
|
||||
{
|
||||
private ulong m_NetworkObjectId;
|
||||
private static ulong s_NullId = ulong.MaxValue;
|
||||
|
||||
/// <summary>
|
||||
/// The <see cref="NetworkObject.NetworkObjectId"/> of the referenced <see cref="NetworkObject"/>.
|
||||
@@ -24,13 +25,13 @@ namespace Unity.Netcode
|
||||
/// Creates a new instance of the <see cref="NetworkObjectReference"/> struct.
|
||||
/// </summary>
|
||||
/// <param name="networkObject">The <see cref="NetworkObject"/> to reference.</param>
|
||||
/// <exception cref="ArgumentNullException"></exception>
|
||||
/// <exception cref="ArgumentException"></exception>
|
||||
public NetworkObjectReference(NetworkObject networkObject)
|
||||
{
|
||||
if (networkObject == null)
|
||||
{
|
||||
throw new ArgumentNullException(nameof(networkObject));
|
||||
m_NetworkObjectId = s_NullId;
|
||||
return;
|
||||
}
|
||||
|
||||
if (networkObject.IsSpawned == false)
|
||||
@@ -45,16 +46,20 @@ namespace Unity.Netcode
|
||||
/// Creates a new instance of the <see cref="NetworkObjectReference"/> struct.
|
||||
/// </summary>
|
||||
/// <param name="gameObject">The GameObject from which the <see cref="NetworkObject"/> component will be referenced.</param>
|
||||
/// <exception cref="ArgumentNullException"></exception>
|
||||
/// <exception cref="ArgumentException"></exception>
|
||||
public NetworkObjectReference(GameObject gameObject)
|
||||
{
|
||||
if (gameObject == null)
|
||||
{
|
||||
throw new ArgumentNullException(nameof(gameObject));
|
||||
m_NetworkObjectId = s_NullId;
|
||||
return;
|
||||
}
|
||||
|
||||
var networkObject = gameObject.GetComponent<NetworkObject>() ?? throw new ArgumentException($"Cannot create {nameof(NetworkObjectReference)} from {nameof(GameObject)} without a {nameof(NetworkObject)} component.");
|
||||
var networkObject = gameObject.GetComponent<NetworkObject>();
|
||||
if (!networkObject)
|
||||
{
|
||||
throw new ArgumentException($"Cannot create {nameof(NetworkObjectReference)} from {nameof(GameObject)} without a {nameof(NetworkObject)} component.");
|
||||
}
|
||||
if (networkObject.IsSpawned == false)
|
||||
{
|
||||
throw new ArgumentException($"{nameof(NetworkObjectReference)} can only be created from spawned {nameof(NetworkObject)}s.");
|
||||
@@ -80,10 +85,14 @@ namespace Unity.Netcode
|
||||
/// </summary>
|
||||
/// <param name="networkObjectRef">The reference.</param>
|
||||
/// <param name="networkManager">The networkmanager. Uses <see cref="NetworkManager.Singleton"/> to resolve if null.</param>
|
||||
/// <returns>The resolves <see cref="NetworkObject"/>. Returns null if the networkobject was not found</returns>
|
||||
/// <returns>The resolved <see cref="NetworkObject"/>. Returns null if the networkobject was not found</returns>
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
private static NetworkObject Resolve(NetworkObjectReference networkObjectRef, NetworkManager networkManager = null)
|
||||
{
|
||||
if (networkObjectRef.m_NetworkObjectId == s_NullId)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
networkManager = networkManager ?? NetworkManager.Singleton;
|
||||
networkManager.SpawnManager.SpawnedObjects.TryGetValue(networkObjectRef.m_NetworkObjectId, out NetworkObject networkObject);
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user