diff --git a/com.unity.netcode.gameobjects/Runtime/Components/AnticipatedNetworkTransform.cs b/com.unity.netcode.gameobjects/Runtime/Components/AnticipatedNetworkTransform.cs index 913447beb1..193a292136 100644 --- a/com.unity.netcode.gameobjects/Runtime/Components/AnticipatedNetworkTransform.cs +++ b/com.unity.netcode.gameobjects/Runtime/Components/AnticipatedNetworkTransform.cs @@ -286,6 +286,7 @@ private void ProcessSmoothing() // TODO: This does not handle OnFixedUpdate // This requires a complete overhaul in this class to switch between using // NetworkRigidbody's position and rotation values. + /// public override void OnUpdate() { ProcessSmoothing(); @@ -422,6 +423,7 @@ protected internal override void InternalOnNetworkPostSpawn() } } + /// public override void OnNetworkSpawn() { if (NetworkManager.DistributedAuthorityMode) @@ -445,6 +447,7 @@ public override void OnNetworkSpawn() NetworkManager.AnticipationSystem.AllAnticipatedObjects.Add(m_AnticipatedObject); } + /// public override void OnNetworkDespawn() { if (m_AnticipatedObject != null) @@ -459,6 +462,7 @@ public override void OnNetworkDespawn() base.OnNetworkDespawn(); } + /// public override void OnDestroy() { if (m_AnticipatedObject != null) @@ -510,6 +514,7 @@ public void Smooth(TransformState from, TransformState to, float durationSeconds m_CurrentSmoothTime = 0; } + /// protected override void OnBeforeUpdateTransformState() { // this is called when new data comes from the server @@ -517,12 +522,14 @@ protected override void OnBeforeUpdateTransformState() 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) diff --git a/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkConfig.cs b/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkConfig.cs index 826fb15ecf..00e7719e4a 100644 --- a/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkConfig.cs +++ b/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkConfig.cs @@ -39,6 +39,9 @@ public class NetworkConfig [Tooltip("When set, NetworkManager will automatically create and spawn the assigned player prefab. This can be overridden by adding it to the NetworkPrefabs list and selecting override.")] public GameObject PlayerPrefab; + /// + /// The collection of network prefabs that can be spawned across the network + /// [SerializeField] public NetworkPrefabs Prefabs = new NetworkPrefabs(); @@ -159,12 +162,21 @@ public class NetworkConfig /// public const int RttWindowSize = 64; // number of slots to use for RTT computations (max number of in-flight packets) + /// + /// Determines whether to use the client-server or distributed authority network topology + /// [Tooltip("Determines whether to use the client-server or distributed authority network topology.")] public NetworkTopologyTypes NetworkTopology; + /// + /// Internal flag for Cloud Multiplayer Build service integration + /// [HideInInspector] public bool UseCMBService; + /// + /// When enabled (default), the player prefab will automatically be spawned client-side upon the client being approved and synchronized + /// [Tooltip("When enabled (default), the player prefab will automatically be spawned (client-side) upon the client being approved and synchronized.")] public bool AutoSpawnPlayerPrefabClientSide = true; @@ -205,7 +217,7 @@ internal NetworkConfig Copy() return networkConfig; } -#endif +#endif #if MULTIPLAYER_TOOLS diff --git a/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefab.cs b/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefab.cs index 9cc2158cc1..c6f30d2835 100644 --- a/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefab.cs +++ b/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefab.cs @@ -57,6 +57,11 @@ public class NetworkPrefab /// public GameObject OverridingTargetPrefab; + /// + /// Compares this NetworkPrefab with another to determine equality + /// + /// The NetworkPrefab to compare against + /// True if all fields match between the two NetworkPrefabs, false otherwise public bool Equals(NetworkPrefab other) { return Override == other.Override && @@ -66,6 +71,12 @@ public bool Equals(NetworkPrefab other) OverridingTargetPrefab == other.OverridingTargetPrefab; } + /// + /// Gets the GlobalObjectIdHash of the source prefab based on the current override settings + /// + /// The hash value identifying the source prefab + /// Thrown when required prefab references are missing or invalid + /// Thrown when Override has an invalid value public uint SourcePrefabGlobalObjectIdHash { get @@ -98,6 +109,12 @@ public uint SourcePrefabGlobalObjectIdHash } } + /// + /// Gets the GlobalObjectIdHash of the target prefab when using prefab overrides + /// + /// The hash value identifying the target prefab, or 0 if no override is set + /// Thrown when required prefab references are missing or invalid + /// Thrown when Override has an invalid value public uint TargetPrefabGlobalObjectIdHash { get @@ -122,6 +139,11 @@ public uint TargetPrefabGlobalObjectIdHash } } + /// + /// Validates the NetworkPrefab configuration to ensure all required fields are properly set + /// + /// Optional index used for error reporting when validating lists of prefabs + /// True if the NetworkPrefab is valid and ready for use, false otherwise public bool Validate(int index = -1) { NetworkObject networkObject; @@ -224,6 +246,10 @@ public bool Validate(int index = -1) return true; } + /// + /// Returns a string representation of this NetworkPrefab's source and target hash values + /// + /// A string containing the source and target hash values public override string ToString() { return $"{{SourceHash: {SourceHashToOverride}, TargetHash: {TargetPrefabGlobalObjectIdHash}}}"; diff --git a/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefabs.cs b/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefabs.cs index 42758f7e78..6e801f5b61 100644 --- a/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefabs.cs +++ b/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefabs.cs @@ -39,6 +39,9 @@ public class NetworkPrefabs [NonSerialized] public Dictionary OverrideToNetworkPrefab = new Dictionary(); + /// + /// Gets the read-only list of all registered network prefabs + /// public IReadOnlyList Prefabs => m_Prefabs; [NonSerialized] @@ -62,6 +65,9 @@ private void RemoveTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab) m_Prefabs.Remove(networkPrefab); } + /// + /// Finalizer that ensures proper cleanup of network prefab resources + /// ~NetworkPrefabs() { Shutdown(); @@ -84,6 +90,7 @@ internal void Shutdown() /// Processes the if one is present for use during runtime execution, /// else processes . /// + /// When true, logs warnings about invalid prefabs that are removed during initialization public void Initialize(bool warnInvalid = true) { m_Prefabs.Clear(); @@ -156,6 +163,8 @@ public void Initialize(bool warnInvalid = true) /// /// Add a new NetworkPrefab instance to the list /// + /// The NetworkPrefab to add + /// True if the prefab was successfully added, false if it was invalid or already registered /// /// The framework does not synchronize this list between clients. Any runtime changes must be handled manually. /// @@ -177,6 +186,7 @@ public bool Add(NetworkPrefab networkPrefab) /// /// Remove a NetworkPrefab instance from the list /// + /// The NetworkPrefab to remove /// /// The framework does not synchronize this list between clients. Any runtime changes must be handled manually. /// @@ -199,6 +209,7 @@ public void Remove(NetworkPrefab prefab) /// /// Remove a NetworkPrefab instance with matching from the list /// + /// The GameObject to match against for removal /// /// The framework does not synchronize this list between clients. Any runtime changes must be handled manually. /// diff --git a/com.unity.netcode.gameobjects/Runtime/Connection/NetworkClient.cs b/com.unity.netcode.gameobjects/Runtime/Connection/NetworkClient.cs index ff6ed614e1..eefe269ca4 100644 --- a/com.unity.netcode.gameobjects/Runtime/Connection/NetworkClient.cs +++ b/com.unity.netcode.gameobjects/Runtime/Connection/NetworkClient.cs @@ -34,8 +34,14 @@ public class NetworkClient /// internal bool IsApproved { get; set; } + /// + /// Defines the network topology type being used for the current network session + /// public NetworkTopologyTypes NetworkTopologyType { get; internal set; } + /// + /// Indicates whether this client is running in Distributed Authority Host mode + /// public bool DAHost { get; internal set; } /// diff --git a/com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs b/com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs index a95df88a4e..dbdff3ca2b 100644 --- a/com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs +++ b/com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs @@ -60,6 +60,9 @@ public enum ConnectionEvent /// public struct ConnectionEventData { + /// + /// The type of connection event that occurred + /// public ConnectionEvent EventType; /// diff --git a/com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviour.cs b/com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviour.cs index 1f98d0b840..7113917944 100644 --- a/com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviour.cs +++ b/com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviour.cs @@ -6,8 +6,15 @@ namespace Unity.Netcode { + /// + /// Exception thrown when an RPC (Remote Procedure Call) encounters an error during execution + /// public class RpcException : Exception { + /// + /// Initializes a new instance of the RpcException class with a specified error message + /// + /// The message that describes the error public RpcException(string message) : base(message) { @@ -694,6 +701,9 @@ public virtual void OnNetworkSpawn() { } /// protected virtual void OnNetworkPostSpawn() { } + /// + /// Internal implementation of post-spawn functionality. Called after OnNetworkSpawn to handle internal post-spawn operations. + /// protected internal virtual void InternalOnNetworkPostSpawn() { } /// @@ -708,6 +718,9 @@ protected internal virtual void InternalOnNetworkPostSpawn() { } /// protected virtual void OnNetworkSessionSynchronized() { } + /// + /// Internal implementation of network session synchronization. Handles the internal processing of session synchronization events. + /// protected internal virtual void InternalOnNetworkSessionSynchronized() { } /// @@ -1386,6 +1399,11 @@ protected virtual void OnSynchronize(ref BufferSerializer serializer) wher } + /// + /// Called when network conditions require reanticipation of game state. + /// Override this method to handle adjustments needed when network latency changes. + /// + /// The most recent round trip time measurement in seconds public virtual void OnReanticipate(double lastRoundTripTime) { diff --git a/com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs b/com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs index eed0bc497c..f0e388d72e 100644 --- a/com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs +++ b/com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs @@ -201,6 +201,9 @@ internal void HandleRedistributionToClients() internal List DeferredDespawnObjects = new List(); + /// + /// Gets the client identifier of the current session owner in distributed authority mode + /// public ulong CurrentSessionOwner { get; internal set; } /// @@ -312,6 +315,10 @@ private void UpdateTopology() } } + /// + /// Processes network-related updates for a specific update stage in the frame + /// + /// The current network update stage being processed public void NetworkUpdate(NetworkUpdateStage updateStage) { switch (updateStage) @@ -643,6 +650,10 @@ public event Action OnTransportFailure remove => ConnectionManager.OnTransportFailure -= value; } + /// + /// Delegate for handling network state reanticipation events + /// + /// The most recent round-trip time measurement in seconds between client and server public delegate void ReanticipateDelegate(double lastRoundTripTime); /// diff --git a/com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs b/com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs index 4b6c43feb4..502ffefcb6 100644 --- a/com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs +++ b/com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs @@ -533,22 +533,27 @@ public enum OwnershipStatus /// When set, this instance will have no permissions (i.e. cannot distribute, transfer, etc). /// None = 0, + /// /// When set, this instance will be automatically redistributed when a client joins (if not locked or no request is pending) or leaves. /// Distributable = 1 << 0, + /// /// When set, a non-owner can obtain ownership immediately (without requesting and as long as it is not locked). /// Transferable = 1 << 1, + /// /// When set, a non-owner must request ownership from the owner (will always get locked once ownership is transferred). /// RequestRequired = 1 << 2, + /// /// When set, only the current session owner may have ownership over this object. /// SessionOwner = 1 << 3, + /// /// Used within the inspector view only. When selected it will set the Distributable, Transferable, and RequestRequired flags or if those flags are already set it will select the SessionOwner flag by itself. /// @@ -648,10 +653,29 @@ public bool SetOwnershipLock(bool lockOwnership = true) /// public enum OwnershipPermissionsFailureStatus { + /// + /// The NetworkObject is locked and ownership cannot be acquired + /// Locked, + + /// + /// The NetworkObject requires an ownership request via RequestOwnership + /// RequestRequired, + + /// + /// The NetworkObject is already processing an ownership request and ownership cannot be acquired at this time + /// RequestInProgress, + + /// + /// The NetworkObject does not have the OwnershipStatus.Transferable flag set and ownership cannot be acquired + /// NotTransferrable, + + /// + /// The NetworkObject has the OwnershipStatus.SessionOwner flag set and ownership cannot be acquired + /// SessionOwnerOnly } @@ -679,11 +703,35 @@ public enum OwnershipPermissionsFailureStatus /// public enum OwnershipRequestStatus { + /// + /// The request for ownership was sent (does not mean it will be granted, but the request was sent) + /// RequestSent, + + /// + /// The current client is already the owner (no need to request ownership) + /// AlreadyOwner, + + /// + /// The OwnershipStatus.RequestRequired flag is not set on this NetworkObject + /// RequestRequiredNotSet, + + /// + /// The current owner has locked ownership which means requests are not available at this time + /// Locked, + + /// + /// There is already a known request in progress. You can scan for ownership changes and try again + /// after a specific period of time or no longer attempt to request ownership + /// RequestInProgress, + + /// + /// This object is marked as SessionOwnerOnly and therefore cannot be requested + /// SessionOwnerOnly, } @@ -841,19 +889,31 @@ internal void OwnershipRequest(ulong clientRequestingOwnership) /// /// What is returned via after an ownership request has been sent via /// - /// - /// Approved: Granted ownership, and returned after the requesting client has gained ownership on the local instance. - /// Locked: Was locked after request was sent. - /// RequestInProgress: A request started before this request was received. - /// CannotRequest: The RequestRequired status changed while the request was in flight. - /// Denied: General denied message that is only set if returns false by the authority instance. - /// public enum OwnershipRequestResponseStatus { + /// + /// The ownership request was approved and the requesting client has gained ownership on the local instance + /// Approved, + + /// + /// The ownership request was denied because the object became locked after the request was sent + /// Locked, + + /// + /// The ownership request was denied because another request was already in progress when this request was received + /// RequestInProgress, + + /// + /// The ownership request was denied because the RequestRequired status changed while the request was in flight + /// CannotRequest, + + /// + /// The ownership request was denied by the authority instance ( returned false) + /// Denied, } @@ -888,8 +948,19 @@ internal void OwnershipRequestResponse(OwnershipRequestResponseStatus ownershipR /// public enum OwnershipLockActions { + /// + /// No additional locking action will be performed + /// None, + + /// + /// Sets the specified ownership flags and then locks the NetworkObject + /// SetAndLock, + + /// + /// Sets the specified ownership flags and then unlocks the NetworkObject + /// SetAndUnlock } @@ -1115,6 +1186,10 @@ private bool InternalHasAuthority() public bool? IsSceneObject { get; internal set; } //DANGOEXP TODO: Determine if we want to keep this + /// + /// Sets whether this NetworkObject was instantiated as part of a scene + /// + /// When true, marks this as a scene-instantiated object; when false, marks it as runtime-instantiated public void SetSceneObjectStatus(bool isSceneObject = false) { IsSceneObject = isSceneObject; @@ -1186,6 +1261,7 @@ public void SetSceneObjectStatus(bool isSceneObject = false) /// Delegate type for checking visibility /// /// The clientId to check visibility for + /// True if the object should be visible to the specified client, false otherwise public delegate bool VisibilityDelegate(ulong clientId); /// @@ -1197,6 +1273,7 @@ public void SetSceneObjectStatus(bool isSceneObject = false) /// Delegate type for checking spawn options /// /// The clientId to check spawn options for + /// True if the object should be spawned for the specified client, false otherwise public delegate bool SpawnDelegate(ulong clientId); /// @@ -2676,6 +2753,14 @@ internal bool SetNetworkVariableData(FastBufferReader reader, ulong clientId) return true; } + /// + /// Gets the order index of a NetworkBehaviour instance within the ChildNetworkBehaviours collection + /// + /// The NetworkBehaviour instance to find the index for + /// + /// The index of the NetworkBehaviour in the ChildNetworkBehaviours collection. + /// Returns 0 if the instance is not found. + /// public ushort GetNetworkBehaviourOrderIndex(NetworkBehaviour instance) { // read the cached index, and verify it first diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/CustomMessageManager.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/CustomMessageManager.cs index 9a83c6dcc5..815e38d35c 100644 --- a/com.unity.netcode.gameobjects/Runtime/Messaging/CustomMessageManager.cs +++ b/com.unity.netcode.gameobjects/Runtime/Messaging/CustomMessageManager.cs @@ -161,6 +161,8 @@ public void SendUnnamedMessage(ulong clientId, FastBufferWriter messageBuffer, N /// /// Delegate used to handle named messages /// + /// The client identifier of the message sender + /// The buffer containing the message data to be read public delegate void HandleNamedMessageDelegate(ulong senderClientId, FastBufferReader messagePayload); private Dictionary m_NamedMessageHandlers32 = new Dictionary(); diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/GenerateSerializationForGenericParameterAttribute.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/GenerateSerializationForGenericParameterAttribute.cs index a102f3666e..c8d4cedf45 100644 --- a/com.unity.netcode.gameobjects/Runtime/Messaging/GenerateSerializationForGenericParameterAttribute.cs +++ b/com.unity.netcode.gameobjects/Runtime/Messaging/GenerateSerializationForGenericParameterAttribute.cs @@ -74,6 +74,10 @@ public class GenerateSerializationForGenericParameterAttribute : Attribute { internal int ParameterIndex; + /// + /// Initializes a new instance of the attribute + /// + /// The zero-based index of the generic parameter that should be serialized public GenerateSerializationForGenericParameterAttribute(int parameterIndex) { ParameterIndex = parameterIndex; diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/GenerateSerializationForTypeAttribute.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/GenerateSerializationForTypeAttribute.cs index 81e55c00df..5bfff33864 100644 --- a/com.unity.netcode.gameobjects/Runtime/Messaging/GenerateSerializationForTypeAttribute.cs +++ b/com.unity.netcode.gameobjects/Runtime/Messaging/GenerateSerializationForTypeAttribute.cs @@ -18,6 +18,10 @@ public class GenerateSerializationForTypeAttribute : Attribute { internal Type Type; + /// + /// Initializes a new instance of the attribute + /// + /// The type that should have serialization code generated for it public GenerateSerializationForTypeAttribute(Type type) { Type = type; diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/RpcAttributes.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/RpcAttributes.cs index acb6289b5b..6d276ab580 100644 --- a/com.unity.netcode.gameobjects/Runtime/Messaging/RpcAttributes.cs +++ b/com.unity.netcode.gameobjects/Runtime/Messaging/RpcAttributes.cs @@ -24,12 +24,29 @@ public enum RpcDelivery [AttributeUsage(AttributeTargets.Method)] public class RpcAttribute : Attribute { - // Must match the set of parameters below + /// + /// Parameters that define the behavior of an RPC attribute + /// public struct RpcAttributeParams { + /// + /// Specifies the delivery method for the RPC + /// public RpcDelivery Delivery; + + /// + /// When true, only the owner of the object can execute this RPC + /// public bool RequireOwnership; + + /// + /// When true, local execution of the RPC is deferred until the next network tick + /// public bool DeferLocal; + + /// + /// When true, allows the RPC target to be overridden at runtime + /// public bool AllowTargetOverride; } @@ -38,10 +55,26 @@ public struct RpcAttributeParams /// Type of RPC delivery method /// public RpcDelivery Delivery = RpcDelivery.Reliable; + + /// + /// When true, only the owner of the object can execute this RPC + /// public bool RequireOwnership; + + /// + /// When true, local execution of the RPC is deferred until the next network tick + /// public bool DeferLocal; + + /// + /// When true, allows the RPC target to be overridden at runtime + /// public bool AllowTargetOverride; + /// + /// Initializes a new instance of the RpcAttribute with the specified target + /// + /// The target for this RPC public RpcAttribute(SendTo target) { } @@ -60,8 +93,15 @@ private RpcAttribute() [AttributeUsage(AttributeTargets.Method)] public class ServerRpcAttribute : RpcAttribute { + /// + /// When true, only the owner of the NetworkObject can invoke this ServerRpc. + /// This property overrides the base RpcAttribute.RequireOwnership. + /// public new bool RequireOwnership; + /// + /// Initializes a new instance of ServerRpcAttribute that targets the server + /// public ServerRpcAttribute() : base(SendTo.Server) { @@ -75,6 +115,9 @@ public ServerRpcAttribute() : base(SendTo.Server) [AttributeUsage(AttributeTargets.Method)] public class ClientRpcAttribute : RpcAttribute { + /// + /// Initializes a new instance of ClientRpcAttribute that targets all clients except the server + /// public ClientRpcAttribute() : base(SendTo.NotServer) { diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/RpcParams.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/RpcParams.cs index 7eb1a18009..b302e3f8f7 100644 --- a/com.unity.netcode.gameobjects/Runtime/Messaging/RpcParams.cs +++ b/com.unity.netcode.gameobjects/Runtime/Messaging/RpcParams.cs @@ -3,22 +3,54 @@ namespace Unity.Netcode { + /// + /// Specifies how RPC messages should be handled in terms of local execution timing + /// public enum LocalDeferMode { + /// + /// Uses the default behavior for RPC message handling + /// Default, + + /// + /// Defers the local execution of the RPC until the next network tick + /// Defer, + + /// + /// Executes the RPC immediately on the local client without waiting for network synchronization + /// SendImmediate } + /// - /// Generic RPC + /// Generic RPC. Defines parameters for sending Remote Procedure Calls (RPCs) in the network system /// public struct RpcSendParams { + /// + /// Specifies the target that will receive this RPC + /// public BaseRpcTarget Target; + /// + /// Controls how the RPC is handled for local execution timing + /// public LocalDeferMode LocalDeferMode; + /// + /// Implicitly converts a BaseRpcTarget to RpcSendParams + /// + /// The RPC target to convert + /// A new RpcSendParams instance with the specified target public static implicit operator RpcSendParams(BaseRpcTarget target) => new RpcSendParams { Target = target }; + + /// + /// Implicitly converts a LocalDeferMode to RpcSendParams + /// + /// The defer mode to convert + /// A new RpcSendParams instance with the specified defer mode public static implicit operator RpcSendParams(LocalDeferMode deferMode) => new RpcSendParams { LocalDeferMode = deferMode }; } @@ -51,9 +83,32 @@ public struct RpcParams /// public RpcReceiveParams Receive; + /// + /// Implicitly converts RpcSendParams to RpcParams + /// + /// The send parameters to convert + /// A new RpcParams instance with the specified send parameters public static implicit operator RpcParams(RpcSendParams send) => new RpcParams { Send = send }; + + /// + /// Implicitly converts a BaseRpcTarget to RpcParams + /// + /// The RPC target to convert + /// A new RpcParams instance with the specified target in its send parameters public static implicit operator RpcParams(BaseRpcTarget target) => new RpcParams { Send = new RpcSendParams { Target = target } }; + + /// + /// Implicitly converts a LocalDeferMode to RpcParams + /// + /// The defer mode to convert + /// A new RpcParams instance with the specified defer mode in its send parameters public static implicit operator RpcParams(LocalDeferMode deferMode) => new RpcParams { Send = new RpcSendParams { LocalDeferMode = deferMode } }; + + /// + /// Implicitly converts RpcReceiveParams to RpcParams + /// + /// The receive parameters to convert + /// A new RpcParams instance with the specified receive parameters public static implicit operator RpcParams(RpcReceiveParams receive) => new RpcParams { Receive = receive }; } diff --git a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/AnticipatedNetworkVariable.cs b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/AnticipatedNetworkVariable.cs index 94625722e3..5fe5d40818 100644 --- a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/AnticipatedNetworkVariable.cs +++ b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/AnticipatedNetworkVariable.cs @@ -4,10 +4,21 @@ namespace Unity.Netcode { - + /// + /// Defines how anticipated network variables handle authoritative updates that are older than the current anticipated state + /// public enum StaleDataHandling { + /// + /// Ignores authoritative updates that are older than the current anticipated state. + /// The anticipated value will not be replaced until a newer authoritative update is received. + /// Ignore, + + /// + /// Applies authoritative updates even if they are older than the current anticipated state. + /// This triggers reanticipation to calculate a new anticipated value based on the authoritative state. + /// Reanticipate } @@ -83,8 +94,18 @@ public class AnticipatedNetworkVariable : NetworkVariableBase /// the anticipationTime value, and that callback can be used to calculate a new anticipated value. /// #pragma warning restore IDE0001 + + /// + /// Controls how this network variable handles authoritative updates that are older than the current anticipated state + /// public StaleDataHandling StaleDataHandling; + /// + /// Delegate for handling changes in the authoritative value + /// + /// The network variable that changed + /// The previous value before the change + /// The new value after the change public delegate void OnAuthoritativeValueChangedDelegate(AnticipatedNetworkVariable variable, in T previousValue, in T newValue); /// @@ -121,6 +142,9 @@ public void ResetAnticipation() private AnticipatedObject m_AnticipatedObject; + /// + /// Initializes the network variable, setting up initial values and registering with the anticipation system + /// public override void OnInitialize() { m_AuthoritativeValue.Initialize(m_NetworkBehaviour); @@ -133,6 +157,10 @@ public override void OnInitialize() } } + /// + /// Checks if the current value has changed enough from its last synchronized value to warrant a new network update + /// + /// True if the value should be synchronized, false otherwise public override bool ExceedsDirtinessThreshold() { return m_AuthoritativeValue.ExceedsDirtinessThreshold(); @@ -227,10 +255,19 @@ public T AuthoritativeValue /// See , , , and so on /// for examples. /// + /// The authoritative value to interpolate from + /// The anticipated value to interpolate to + /// The interpolation factor between 0 and 1 + /// The interpolated value public delegate T SmoothDelegate(T authoritativeValue, T anticipatedValue, float amount); private SmoothDelegate m_SmoothDelegate = null; + /// + /// Initializes a new instance of the AnticipatedNetworkVariable class + /// + /// The initial value for the network variable. Defaults to the type's default value if not specified. + /// Determines how the variable handles authoritative updates that are older than the current anticipated state. Defaults to StaleDataHandling.Ignore. public AnticipatedNetworkVariable(T value = default, StaleDataHandling staleDataHandling = StaleDataHandling.Ignore) : base() @@ -242,6 +279,9 @@ public AnticipatedNetworkVariable(T value = default, }; } + /// + /// Updates the smooth interpolation state if active + /// public void Update() { if (m_CurrentSmoothTime < m_SmoothDuration) @@ -253,6 +293,7 @@ public void Update() } } + /// public override void Dispose() { if (m_IsDisposed) @@ -302,6 +343,9 @@ public override void Dispose() } } + /// + /// Finalizer that ensures proper cleanup of network variable resources + /// ~AnticipatedNetworkVariable() { Dispose(); @@ -357,26 +401,31 @@ public void Smooth(in T from, in T to, float durationSeconds, 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); @@ -384,6 +433,7 @@ public override void ReadField(FastBufferReader reader) NetworkVariableSerialization.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue); } + /// public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta) { m_AuthoritativeValue.ReadDelta(reader, keepDirtyDelta); diff --git a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Collections/NetworkList.cs b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Collections/NetworkList.cs index 72258c77f5..97fbeabc72 100644 --- a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Collections/NetworkList.cs +++ b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Collections/NetworkList.cs @@ -49,6 +49,9 @@ public NetworkList(IEnumerable values = default, } } + /// + /// Finalizer that ensures proper cleanup of network list resources + /// ~NetworkList() { Dispose(); diff --git a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/NetworkVariable.cs b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/NetworkVariable.cs index 66fae6a82a..21f92957d2 100644 --- a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/NetworkVariable.cs +++ b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/NetworkVariable.cs @@ -22,10 +22,23 @@ public class NetworkVariable : NetworkVariableBase /// public OnValueChangedDelegate OnValueChanged; + /// + /// Delegate that determines if the difference between two values exceeds a threshold for network synchronization + /// + /// The previous value to compare against + /// The new value to compare + /// True if the difference exceeds the threshold and should be synchronized, false otherwise public delegate bool CheckExceedsDirtinessThresholdDelegate(in T previousValue, in T newValue); + /// + /// Delegate instance for checking if value changes exceed the dirtiness threshold + /// public CheckExceedsDirtinessThresholdDelegate CheckExceedsDirtinessThreshold; + /// + /// Determines if the current value has changed enough from its previous value to warrant network synchronization + /// + /// True if the value should be synchronized, false otherwise public override bool ExceedsDirtinessThreshold() { if (CheckExceedsDirtinessThreshold != null && m_HasPreviousValue) @@ -36,6 +49,9 @@ public override bool ExceedsDirtinessThreshold() return true; } + /// + /// Initializes the NetworkVariable by setting up initial and previous values + /// public override void OnInitialize() { base.OnInitialize(); @@ -140,6 +156,7 @@ public virtual T Value /// If you invoked this when a collection is dirty, it will not trigger the unless you set forceCheck param to true.
/// /// when true, this check will force a full item collection check even if the NetworkVariable is already dirty + /// True if the variable is dirty and needs synchronization, false otherwise public bool CheckDirtyState(bool forceCheck = false) { var isDirty = base.IsDirty(); @@ -178,6 +195,7 @@ internal ref T RefValue() return ref m_InternalValue; } + /// public override void Dispose() { if (m_IsDisposed) @@ -211,6 +229,9 @@ public override void Dispose() base.Dispose(); } + /// + /// Finalizer that ensures proper cleanup of resources + /// ~NetworkVariable() { Dispose(); diff --git a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/NetworkVariableBase.cs b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/NetworkVariableBase.cs index e8e7221f78..6b97ce90e3 100644 --- a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/NetworkVariableBase.cs +++ b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/NetworkVariableBase.cs @@ -3,11 +3,20 @@ namespace Unity.Netcode { + /// + /// Defines update timing constraints for NetworkVariables + /// public struct NetworkVariableUpdateTraits { + /// + /// 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. + /// [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; + /// + /// 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. + /// [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; } @@ -53,6 +62,10 @@ internal void LogWritePermissionError() private protected NetworkManager m_NetworkManager => m_InternalNetworkManager; + /// + /// Gets the NetworkBehaviour instance associated with this network variable + /// + /// The NetworkBehaviour that owns this network variable public NetworkBehaviour GetBehaviour() { return m_NetworkBehaviour; @@ -98,7 +111,7 @@ public void Initialize(NetworkBehaviour networkBehaviour) if (!m_NetworkBehaviour.NetworkObject.NetworkManagerOwner) { // Exit early if there has yet to be a NetworkManagerOwner assigned - // to the NetworkObject. This is ok because Initialize is invoked + // to the NetworkObject. This is ok because Initialize is invoked // multiple times until it is considered "initialized". return; } @@ -259,6 +272,9 @@ internal void UpdateLastSentTime() internal static bool IgnoreInitializeWarning; + /// + /// Marks the associated NetworkBehaviour as dirty, indicating it needs synchronization + /// protected void MarkNetworkBehaviourDirty() { if (m_NetworkBehaviour == null) diff --git a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/NetworkVariableSerialization.cs b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/NetworkVariableSerialization.cs index b2edd738a3..1a00d2c86a 100644 --- a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/NetworkVariableSerialization.cs +++ b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/NetworkVariableSerialization.cs @@ -15,8 +15,11 @@ public static class NetworkVariableSerialization internal static INetworkVariableSerializer Serializer = new FallbackSerializer(); /// - /// A callback to check if two values are equal. + /// Delegate for comparing two values of type T for equality /// + /// First value to compare + /// Second value to compare + /// True if the values are equal, false otherwise public delegate bool EqualsDelegate(ref T a, ref T b); /// diff --git a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/UserNetworkVariableSerialization.cs b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/UserNetworkVariableSerialization.cs index a85d4fcaf6..3f2a64585c 100644 --- a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/UserNetworkVariableSerialization.cs +++ b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/UserNetworkVariableSerialization.cs @@ -21,6 +21,7 @@ public class UserNetworkVariableSerialization /// /// The to write the value of type `T` /// The value of type `T` to be written + /// The previous value to compute the delta against public delegate void WriteDeltaDelegate(FastBufferWriter writer, in T value, in T previousValue); /// @@ -41,6 +42,7 @@ public class UserNetworkVariableSerialization /// The read value delegate handler definition /// /// The value of type `T` to be read + /// The reference to store the duplicated value in public delegate void DuplicateValueDelegate(in T value, ref T duplicatedValue); /// diff --git a/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs b/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs index e87da1f489..19227c82ba 100644 --- a/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs +++ b/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs @@ -1806,6 +1806,9 @@ internal NetworkSpawnManager(NetworkManager networkManager) NetworkManager = networkManager; } + /// + /// Finalizer that ensures proper cleanup of spawn manager resources + /// ~NetworkSpawnManager() { Shutdown(); diff --git a/com.unity.netcode.gameobjects/Runtime/Transports/NetworkTransport.cs b/com.unity.netcode.gameobjects/Runtime/Transports/NetworkTransport.cs index e39dbc8dfc..b8784fcfb3 100644 --- a/com.unity.netcode.gameobjects/Runtime/Transports/NetworkTransport.cs +++ b/com.unity.netcode.gameobjects/Runtime/Transports/NetworkTransport.cs @@ -28,6 +28,10 @@ public abstract class NetworkTransport : MonoBehaviour /// /// Delegate for transport network events /// + /// The type of network event that occurred + /// The ID of the client associated with this event + /// The data payload received with this event + /// The time when this event was received public delegate void TransportEventDelegate(NetworkEvent eventType, ulong clientId, ArraySegment payload, float receiveTime); /// @@ -171,7 +175,7 @@ internal NetworkTopologyTypes CurrentTopology() public enum NetworkTopologyTypes { /// - /// The traditional client-server network topology. + /// The traditional client-server network topology. /// ClientServer, /// diff --git a/pvpExceptions.json b/pvpExceptions.json index 23263680db..c004d0ed32 100644 --- a/pvpExceptions.json +++ b/pvpExceptions.json @@ -7,143 +7,6 @@ }, "PVP-151-1": { "errors": [ - "Unity.Netcode.Components.AnticipatedNetworkTransform: void OnUpdate(): undocumented", - "Unity.Netcode.Components.AnticipatedNetworkTransform: void OnNetworkSpawn(): undocumented", - "Unity.Netcode.Components.AnticipatedNetworkTransform: void OnNetworkDespawn(): undocumented", - "Unity.Netcode.Components.AnticipatedNetworkTransform: void OnDestroy(): undocumented", - "Unity.Netcode.Components.AnticipatedNetworkTransform: void OnBeforeUpdateTransformState(): undocumented", - "Unity.Netcode.Components.AnticipatedNetworkTransform: void OnNetworkTransformStateUpdated(ref NetworkTransformState, ref NetworkTransformState): undocumented", - "Unity.Netcode.Components.AnticipatedNetworkTransform: void OnTransformUpdated(): undocumented", - "Unity.Netcode.Components.AnticipatedNetworkTransform.TransformState: undocumented", - "Unity.Netcode.Components.AnticipatedNetworkTransform.TransformState: Position: undocumented", - "Unity.Netcode.Components.AnticipatedNetworkTransform.TransformState: Rotation: undocumented", - "Unity.Netcode.Components.AnticipatedNetworkTransform.TransformState: Scale: undocumented", - "Unity.Netcode.NetworkConfig: Prefabs: undocumented", - "Unity.Netcode.NetworkConfig: NetworkTopology: undocumented", - "Unity.Netcode.NetworkConfig: UseCMBService: undocumented", - "Unity.Netcode.NetworkConfig: AutoSpawnPlayerPrefabClientSide: undocumented", - "Unity.Netcode.NetworkPrefab: bool Equals(NetworkPrefab): undocumented", - "Unity.Netcode.NetworkPrefab: SourcePrefabGlobalObjectIdHash: undocumented", - "Unity.Netcode.NetworkPrefab: TargetPrefabGlobalObjectIdHash: undocumented", - "Unity.Netcode.NetworkPrefab: bool Validate(int): undocumented", - "Unity.Netcode.NetworkPrefab: string ToString(): undocumented", - "Unity.Netcode.NetworkPrefabs: Prefabs: undocumented", - "Unity.Netcode.NetworkPrefabs: void Finalize(): undocumented", - "Unity.Netcode.NetworkPrefabs: void Initialize(bool): missing ", - "Unity.Netcode.NetworkPrefabs: bool Add(NetworkPrefab): missing ", - "Unity.Netcode.NetworkPrefabs: bool Add(NetworkPrefab): missing ", - "Unity.Netcode.NetworkPrefabs: void Remove(NetworkPrefab): missing ", - "Unity.Netcode.NetworkPrefabs: void Remove(GameObject): missing ", - "Unity.Netcode.NetworkClient: NetworkTopologyType: undocumented", - "Unity.Netcode.NetworkClient: DAHost: undocumented", - "Unity.Netcode.ConnectionEventData: EventType: undocumented", - "Unity.Netcode.RpcException: undocumented", - "Unity.Netcode.RpcException: .ctor(string): undocumented", - "Unity.Netcode.NetworkBehaviour: void InternalOnNetworkPostSpawn(): undocumented", - "Unity.Netcode.NetworkBehaviour: void InternalOnNetworkSessionSynchronized(): undocumented", - "Unity.Netcode.NetworkBehaviour: void OnReanticipate(double): undocumented", - "Unity.Netcode.NetworkManager: CurrentSessionOwner: undocumented", - "Unity.Netcode.NetworkManager: void NetworkUpdate(NetworkUpdateStage): undocumented", - "Unity.Netcode.NetworkManager.ReanticipateDelegate: undocumented", - "Unity.Netcode.NetworkObject: void SetSceneObjectStatus(bool): undocumented", - "Unity.Netcode.NetworkObject: ushort GetNetworkBehaviourOrderIndex(NetworkBehaviour): undocumented", - "Unity.Netcode.NetworkObject.OwnershipStatus: None: undocumented", - "Unity.Netcode.NetworkObject.OwnershipStatus: Distributable: undocumented", - "Unity.Netcode.NetworkObject.OwnershipStatus: Transferable: undocumented", - "Unity.Netcode.NetworkObject.OwnershipStatus: RequestRequired: undocumented", - "Unity.Netcode.NetworkObject.OwnershipStatus: SessionOwner: undocumented", - "Unity.Netcode.NetworkObject.OwnershipPermissionsFailureStatus: Locked: undocumented", - "Unity.Netcode.NetworkObject.OwnershipPermissionsFailureStatus: RequestRequired: undocumented", - "Unity.Netcode.NetworkObject.OwnershipPermissionsFailureStatus: RequestInProgress: undocumented", - "Unity.Netcode.NetworkObject.OwnershipPermissionsFailureStatus: NotTransferrable: undocumented", - "Unity.Netcode.NetworkObject.OwnershipPermissionsFailureStatus: SessionOwnerOnly: undocumented", - "Unity.Netcode.NetworkObject.OwnershipRequestStatus: RequestSent: undocumented", - "Unity.Netcode.NetworkObject.OwnershipRequestStatus: AlreadyOwner: undocumented", - "Unity.Netcode.NetworkObject.OwnershipRequestStatus: RequestRequiredNotSet: undocumented", - "Unity.Netcode.NetworkObject.OwnershipRequestStatus: Locked: undocumented", - "Unity.Netcode.NetworkObject.OwnershipRequestStatus: RequestInProgress: undocumented", - "Unity.Netcode.NetworkObject.OwnershipRequestStatus: SessionOwnerOnly: undocumented", - "Unity.Netcode.NetworkObject.OwnershipRequestResponseStatus: Approved: undocumented", - "Unity.Netcode.NetworkObject.OwnershipRequestResponseStatus: Locked: undocumented", - "Unity.Netcode.NetworkObject.OwnershipRequestResponseStatus: RequestInProgress: undocumented", - "Unity.Netcode.NetworkObject.OwnershipRequestResponseStatus: CannotRequest: undocumented", - "Unity.Netcode.NetworkObject.OwnershipRequestResponseStatus: Denied: undocumented", - "Unity.Netcode.NetworkObject.OwnershipLockActions: None: undocumented", - "Unity.Netcode.NetworkObject.OwnershipLockActions: SetAndLock: undocumented", - "Unity.Netcode.NetworkObject.OwnershipLockActions: SetAndUnlock: undocumented", - "Unity.Netcode.NetworkObject.VisibilityDelegate: missing ", - "Unity.Netcode.NetworkObject.SpawnDelegate: missing ", - "Unity.Netcode.CustomMessagingManager.HandleNamedMessageDelegate: missing ", - "Unity.Netcode.CustomMessagingManager.HandleNamedMessageDelegate: missing ", - "Unity.Netcode.GenerateSerializationForGenericParameterAttribute: .ctor(int): undocumented", - "Unity.Netcode.GenerateSerializationForTypeAttribute: .ctor(Type): undocumented", - "Unity.Netcode.RpcAttribute: RequireOwnership: undocumented", - "Unity.Netcode.RpcAttribute: DeferLocal: undocumented", - "Unity.Netcode.RpcAttribute: AllowTargetOverride: undocumented", - "Unity.Netcode.RpcAttribute: .ctor(SendTo): undocumented", - "Unity.Netcode.RpcAttribute.RpcAttributeParams: undocumented", - "Unity.Netcode.RpcAttribute.RpcAttributeParams: Delivery: undocumented", - "Unity.Netcode.RpcAttribute.RpcAttributeParams: RequireOwnership: undocumented", - "Unity.Netcode.RpcAttribute.RpcAttributeParams: DeferLocal: undocumented", - "Unity.Netcode.RpcAttribute.RpcAttributeParams: AllowTargetOverride: undocumented", - "Unity.Netcode.ServerRpcAttribute: RequireOwnership: undocumented", - "Unity.Netcode.ServerRpcAttribute: .ctor(): undocumented", - "Unity.Netcode.ClientRpcAttribute: .ctor(): undocumented", - "Unity.Netcode.LocalDeferMode: undocumented", - "Unity.Netcode.LocalDeferMode: Default: undocumented", - "Unity.Netcode.LocalDeferMode: Defer: undocumented", - "Unity.Netcode.LocalDeferMode: SendImmediate: undocumented", - "Unity.Netcode.RpcSendParams: Target: undocumented", - "Unity.Netcode.RpcSendParams: LocalDeferMode: undocumented", - "Unity.Netcode.RpcSendParams: RpcSendParams op_Implicit(BaseRpcTarget): undocumented", - "Unity.Netcode.RpcSendParams: RpcSendParams op_Implicit(LocalDeferMode): undocumented", - "Unity.Netcode.RpcParams: RpcParams op_Implicit(RpcSendParams): undocumented", - "Unity.Netcode.RpcParams: RpcParams op_Implicit(BaseRpcTarget): undocumented", - "Unity.Netcode.RpcParams: RpcParams op_Implicit(LocalDeferMode): undocumented", - "Unity.Netcode.RpcParams: RpcParams op_Implicit(RpcReceiveParams): undocumented", - "Unity.Netcode.StaleDataHandling: undocumented", - "Unity.Netcode.StaleDataHandling: Ignore: undocumented", - "Unity.Netcode.StaleDataHandling: Reanticipate: undocumented", - "Unity.Netcode.AnticipatedNetworkVariable: void OnInitialize(): undocumented", - "Unity.Netcode.AnticipatedNetworkVariable: bool ExceedsDirtinessThreshold(): undocumented", - "Unity.Netcode.AnticipatedNetworkVariable: .ctor(T, StaleDataHandling): undocumented", - "Unity.Netcode.AnticipatedNetworkVariable: void Update(): undocumented", - "Unity.Netcode.AnticipatedNetworkVariable: void Dispose(): undocumented", - "Unity.Netcode.AnticipatedNetworkVariable: void Finalize(): undocumented", - "Unity.Netcode.AnticipatedNetworkVariable: bool IsDirty(): undocumented", - "Unity.Netcode.AnticipatedNetworkVariable: void ResetDirty(): undocumented", - "Unity.Netcode.AnticipatedNetworkVariable: void WriteDelta(FastBufferWriter): undocumented", - "Unity.Netcode.AnticipatedNetworkVariable: void WriteField(FastBufferWriter): undocumented", - "Unity.Netcode.AnticipatedNetworkVariable: void ReadField(FastBufferReader): undocumented", - "Unity.Netcode.AnticipatedNetworkVariable: void ReadDelta(FastBufferReader, bool): undocumented", - "Unity.Netcode.AnticipatedNetworkVariable.OnAuthoritativeValueChangedDelegate: undocumented", - "Unity.Netcode.AnticipatedNetworkVariable.SmoothDelegate: missing ", - "Unity.Netcode.AnticipatedNetworkVariable.SmoothDelegate: missing ", - "Unity.Netcode.AnticipatedNetworkVariable.SmoothDelegate: missing ", - "Unity.Netcode.AnticipatedNetworkVariable.SmoothDelegate: missing ", - "Unity.Netcode.NetworkList: void Finalize(): undocumented", - "Unity.Netcode.NetworkVariable: CheckExceedsDirtinessThreshold: undocumented", - "Unity.Netcode.NetworkVariable: bool ExceedsDirtinessThreshold(): undocumented", - "Unity.Netcode.NetworkVariable: void OnInitialize(): undocumented", - "Unity.Netcode.NetworkVariable: bool CheckDirtyState(bool): missing ", - "Unity.Netcode.NetworkVariable: void Dispose(): undocumented", - "Unity.Netcode.NetworkVariable: void Finalize(): undocumented", - "Unity.Netcode.NetworkVariable.CheckExceedsDirtinessThresholdDelegate: undocumented", - "Unity.Netcode.NetworkVariableUpdateTraits: undocumented", - "Unity.Netcode.NetworkVariableUpdateTraits: MinSecondsBetweenUpdates: undocumented", - "Unity.Netcode.NetworkVariableUpdateTraits: MaxSecondsBetweenUpdates: undocumented", - "Unity.Netcode.NetworkVariableBase: NetworkBehaviour GetBehaviour(): undocumented", - "Unity.Netcode.NetworkVariableBase: void MarkNetworkBehaviourDirty(): undocumented", - "Unity.Netcode.NetworkVariableSerialization.EqualsDelegate: missing ", - "Unity.Netcode.NetworkVariableSerialization.EqualsDelegate: missing ", - "Unity.Netcode.NetworkVariableSerialization.EqualsDelegate: missing ", - "Unity.Netcode.UserNetworkVariableSerialization.WriteDeltaDelegate: missing ", - "Unity.Netcode.UserNetworkVariableSerialization.DuplicateValueDelegate: missing ", - "Unity.Netcode.NetworkSpawnManager: void Finalize(): undocumented", - "Unity.Netcode.NetworkTransport.TransportEventDelegate: missing ", - "Unity.Netcode.NetworkTransport.TransportEventDelegate: missing ", - "Unity.Netcode.NetworkTransport.TransportEventDelegate: missing ", - "Unity.Netcode.NetworkTransport.TransportEventDelegate: missing ", "Unity.Netcode.TestHelpers.Runtime.ObjectNameIdentifier: undocumented", "Unity.Netcode.TestHelpers.Runtime.ObjectNameIdentifier: void OnNetworkSpawn(): undocumented", "Unity.Netcode.TestHelpers.Runtime.ObjectNameIdentifier: void RegisterAndLabelNetworkObject(): undocumented",