diff --git a/CHANGELOG.md b/CHANGELOG.md index 0682f59..970adac 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,38 @@ 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.3.1] - 2023-03-27 + +### Added + +- Added detection and graceful handling of corrupt packets for additional safety. (#2419) + +### Changed + +- The UTP component UI has been updated to be more user-friendly for new users by adding a simple toggle to switch between local-only (127.0.0.1) and remote (0.0.0.0) binding modes, using the toggle "Allow Remote Connections" (#2408) +- Updated `UnityTransport` dependency on `com.unity.transport` to 1.3.3. (#2450) +- `NetworkShow()` of `NetworkObject`s are delayed until the end of the frame to ensure consistency of delta-driven variables like `NetworkList`. +- Dirty `NetworkObject` are reset at end-of-frame and not at serialization time. +- `NetworkHide()` of an object that was just `NetworkShow()`n produces a warning, as remote clients will _not_ get a spawn/despawn pair. +- Renamed the NetworkTransform.SetState parameter `shouldGhostsInterpolate` to `teleportDisabled` for better clarity of what that parameter does. (#2228) +- Network prefabs are now stored in a ScriptableObject that can be shared between NetworkManagers, and have been exposed for public access. By default, a Default Prefabs List is created that contains all NetworkObject prefabs in the project, and new NetworkManagers will default to using that unless that option is turned off in the Netcode for GameObjects settings. Existing NetworkManagers will maintain their existing lists, which can be migrated to the new format via a button in their inspector. (#2322) + +### Fixed + +- Fixed issue where changes to a layer's weight would not synchronize unless a state transition was occurring.(#2399) +- Fixed issue where `NetworkManager.LocalClientId` was returning the `NetworkTransport.ServerClientId` as opposed to the `NetworkManager.m_LocalClientId`. (#2398) +- Fixed issue where a dynamically spawned `NetworkObject` parented under an in-scene placed `NetworkObject` would have its `InScenePlaced` value changed to `true`. This would result in a soft synchronization error for late joining clients. (#2396) +- Fixed a UTP test that was failing when you install Unity Transport package 2.0.0 or newer. (#2347) +- Fixed issue where `NetcodeSettingsProvider` would throw an exception in Unity 2020.3.x versions. (#2345) +- Fixed server side issue where, depending upon component ordering, some NetworkBehaviour components might not have their OnNetworkDespawn method invoked if the client side disconnected. (#2323) +- Fixed a case where data corruption could occur when using UnityTransport when reaching a certain level of send throughput. (#2332) +- Fixed an issue in `UnityTransport` where an exception would be thrown if starting a Relay host/server on WebGL. This exception should only be thrown if using direct connections (where WebGL can't act as a host/server). (#2321) +- Fixed `NetworkAnimator` issue where it was not checking for `AnimatorStateTtansition.destinationStateMachine` and any possible sub-states defined within it. (#2309) +- Fixed `NetworkAnimator` issue where the host client was receiving the ClientRpc animation updates when the host was the owner.(#2309) +- Fixed `NetworkAnimator` issue with using pooled objects and when specific properties are cleaned during despawn and destroy.(#2309) +- Fixed issue where `NetworkAnimator` was checking for animation changes when the associated `NetworkObject` was not spawned.(#2309) +- Corrected an issue with the documentation for BufferSerializer (#2401) + ## [1.2.0] - 2022-11-21 ### Added @@ -22,7 +54,7 @@ Additional documentation and release notes are available at [Multiplayer Documen - Optimized bandwidth usage by encoding most integer fields using variable-length encoding. (#2276) ### Fixed - +- Fixed `IsSpawnedObjectsPendingInDontDestroyOnLoad` is only set to true when loading a scene using `LoadSceneMode.Singleonly`. (#2330) - Fixed issue where `NetworkTransform` components nested under a parent with a `NetworkObject` component (i.e. network prefab) would not have their associated `GameObject`'s transform synchronized. (#2298) - Fixed issue where `NetworkObject`s that failed to instantiate could cause the entire synchronization pipeline to be disrupted/halted for a connecting client. (#2298) - Fixed issue where in-scene placed `NetworkObject`s nested under a `GameObject` would be added to the orphaned children list causing continual console warning log messages. (#2298) diff --git a/Components/AssemblyInfo.cs b/Components/AssemblyInfo.cs index 98d32ca..dca7347 100644 --- a/Components/AssemblyInfo.cs +++ b/Components/AssemblyInfo.cs @@ -1,10 +1,15 @@ using System.Runtime.CompilerServices; #if UNITY_EDITOR -[assembly: InternalsVisibleTo("Unity.Netcode.EditorTests")] -[assembly: InternalsVisibleTo("Unity.Netcode.Editor.CodeGen")] [assembly: InternalsVisibleTo("Unity.Netcode.Editor")] -[assembly: InternalsVisibleTo("TestProject.EditorTests")] -[assembly: InternalsVisibleTo("TestProject.RuntimeTests")] -#endif +[assembly: InternalsVisibleTo("Unity.Netcode.Editor.CodeGen")] +#endif // UNITY_EDITOR + +#if UNITY_INCLUDE_TESTS [assembly: InternalsVisibleTo("Unity.Netcode.RuntimeTests")] +[assembly: InternalsVisibleTo("TestProject.RuntimeTests")] +#if UNITY_EDITOR +[assembly: InternalsVisibleTo("Unity.Netcode.EditorTests")] +[assembly: InternalsVisibleTo("TestProject.EditorTests")] +#endif // UNITY_EDITOR +#endif // UNITY_INCLUDE_TESTS diff --git a/Components/NetworkAnimator.cs b/Components/NetworkAnimator.cs index 258b64e..a942a54 100644 --- a/Components/NetworkAnimator.cs +++ b/Components/NetworkAnimator.cs @@ -23,12 +23,6 @@ internal class NetworkAnimatorStateChangeHandler : INetworkUpdateSystem /// private void FlushMessages() { - foreach (var clientId in m_ClientsToSynchronize) - { - m_NetworkAnimator.ServerSynchronizeNewPlayer(clientId); - } - m_ClientsToSynchronize.Clear(); - foreach (var sendEntry in m_SendParameterUpdates) { m_NetworkAnimator.SendParametersUpdateClientRpc(sendEntry.ParametersUpdateMessage, sendEntry.ClientRpcParams); @@ -64,9 +58,10 @@ public void NetworkUpdate(NetworkUpdateStage updateStage) } // Everyone applies any parameters updated - foreach (var parameterUpdate in m_ProcessParameterUpdates) + for (int i = 0; i < m_ProcessParameterUpdates.Count; i++) { - m_NetworkAnimator.UpdateParameters(parameterUpdate); + var parameterUpdate = m_ProcessParameterUpdates[i]; + m_NetworkAnimator.UpdateParameters(ref parameterUpdate); } m_ProcessParameterUpdates.Clear(); @@ -80,20 +75,6 @@ public void NetworkUpdate(NetworkUpdateStage updateStage) } } - /// - /// Clients that need to be synchronized to the relative Animator - /// - private List m_ClientsToSynchronize = new List(); - - /// - /// When a new client is connected, they are added to the - /// m_ClientsToSynchronize list. - /// - internal void SynchronizeClient(ulong clientId) - { - m_ClientsToSynchronize.Add(clientId); - } - /// /// A pending outgoing Animation update for (n) clients /// @@ -157,13 +138,6 @@ internal void QueueTriggerUpdateToServer(NetworkAnimator.AnimationTriggerMessage m_SendTriggerUpdates.Add(new TriggerUpdate() { AnimationTriggerMessage = animationTriggerMessage, SendToServer = true }); } - private Queue m_AnimationMessageQueue = new Queue(); - - internal void AddAnimationMessageToProcessQueue(NetworkAnimator.AnimationMessage message) - { - m_AnimationMessageQueue.Enqueue(message); - } - internal void DeregisterUpdate() { NetworkUpdateLoop.UnregisterNetworkUpdate(this, NetworkUpdateStage.PreUpdate); @@ -226,13 +200,82 @@ private void BuildDestinationToTransitionInfoTable() } } +#if UNITY_EDITOR + private void ParseStateMachineStates(int layerIndex, ref AnimatorController animatorController, ref AnimatorStateMachine stateMachine) + { + for (int y = 0; y < stateMachine.states.Length; y++) + { + var animatorState = stateMachine.states[y].state; + for (int z = 0; z < animatorState.transitions.Length; z++) + { + var transition = animatorState.transitions[z]; + if (transition.conditions.Length == 0 && transition.isExit) + { + // We don't need to worry about exit transitions with no conditions + continue; + } + + foreach (var condition in transition.conditions) + { + var parameterName = condition.parameter; + + var parameters = animatorController.parameters; + // Find the associated parameter for the condition + foreach (var parameter in parameters) + { + // Only process the associated parameter(s) + if (parameter.name != parameterName) + { + continue; + } + + switch (parameter.type) + { + case AnimatorControllerParameterType.Trigger: + { + + if (transition.destinationStateMachine != null) + { + var destinationStateMachine = transition.destinationStateMachine; + ParseStateMachineStates(layerIndex, ref animatorController, ref destinationStateMachine); + } + else if (transition.destinationState != null) + { + var transitionInfo = new TransitionStateinfo() + { + Layer = layerIndex, + OriginatingState = animatorState.nameHash, + DestinationState = transition.destinationState.nameHash, + TransitionDuration = transition.duration, + TriggerNameHash = parameter.nameHash, + TransitionIndex = z + }; + TransitionStateInfoList.Add(transitionInfo); + } + else + { + Debug.LogError($"[{name}][Conditional Transition for {animatorState.name}] Conditional triggered transition has neither a DestinationState nor a DestinationStateMachine! This transition is not likely to synchronize properly. " + + $"Please file a GitHub issue about this error with details about your Animator's setup."); + } + break; + } + default: + break; + } + } + } + } + } + } +#endif + /// /// Creates the TransitionStateInfoList table /// private void BuildTransitionStateInfoList() { #if UNITY_EDITOR - if (UnityEditor.EditorApplication.isUpdating) + if (UnityEditor.EditorApplication.isUpdating || UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode) { return; } @@ -245,54 +288,8 @@ private void BuildTransitionStateInfoList() for (int x = 0; x < animatorController.layers.Length; x++) { - var layer = animatorController.layers[x]; - - for (int y = 0; y < layer.stateMachine.states.Length; y++) - { - var animatorState = layer.stateMachine.states[y].state; - var transitions = layer.stateMachine.GetStateMachineTransitions(layer.stateMachine); - for (int z = 0; z < animatorState.transitions.Length; z++) - { - var transition = animatorState.transitions[z]; - if (transition.conditions.Length == 0 && transition.isExit) - { - // We don't need to worry about exit transitions with no conditions - continue; - } - - foreach (var condition in transition.conditions) - { - var parameterName = condition.parameter; - var parameters = animatorController.parameters; - foreach (var parameter in parameters) - { - switch (parameter.type) - { - case AnimatorControllerParameterType.Trigger: - { - // Match the condition with an existing trigger - if (parameterName == parameter.name) - { - var transitionInfo = new TransitionStateinfo() - { - Layer = x, - OriginatingState = animatorState.nameHash, - DestinationState = transition.destinationState.nameHash, - TransitionDuration = transition.duration, - TriggerNameHash = parameter.nameHash, - TransitionIndex = z - }; - TransitionStateInfoList.Add(transitionInfo); - } - break; - } - default: - break; - } - } - } - } - } + var stateMachine = animatorController.layers[x].stateMachine; + ParseStateMachineStates(x, ref animatorController, ref stateMachine); } #endif } @@ -488,8 +485,17 @@ protected virtual bool OnIsServerAuthoritative() private int[] m_AnimationHash; private float[] m_LayerWeights; private static byte[] s_EmptyArray = new byte[] { }; + private List m_ParametersToUpdate; + private List m_ClientSendList; + private ClientRpcParams m_ClientRpcParams; + private AnimationMessage m_AnimationMessage; private NetworkAnimatorStateChangeHandler m_NetworkAnimatorStateChangeHandler; + /// + /// Used for integration test purposes + /// + internal List SynchronizationStateInfo; + private unsafe struct AnimatorParamCache { internal int Hash; @@ -519,75 +525,44 @@ static AnimationParamEnumWrapper() } } - private void Cleanup() + /// + /// Only things instantiated/created within OnNetworkSpawn should be + /// cleaned up here. + /// + private void SpawnCleanup() { if (m_NetworkAnimatorStateChangeHandler != null) { m_NetworkAnimatorStateChangeHandler.DeregisterUpdate(); m_NetworkAnimatorStateChangeHandler = null; } + } - if (m_CachedNetworkManager != null) - { - m_CachedNetworkManager.OnClientConnectedCallback -= OnClientConnectedCallback; - } + public override void OnDestroy() + { + SpawnCleanup(); if (m_CachedAnimatorParameters != null && m_CachedAnimatorParameters.IsCreated) { m_CachedAnimatorParameters.Dispose(); } + if (m_ParameterWriter.IsInitialized) { m_ParameterWriter.Dispose(); } - } - - public override void OnDestroy() - { - Cleanup(); base.OnDestroy(); } - private List m_ParametersToUpdate; - private List m_ClientSendList; - private ClientRpcParams m_ClientRpcParams; - private AnimationMessage m_AnimationMessage; - - /// - /// Used for integration test to validate that the - /// AnimationMessage.AnimationStates remains the same - /// size as the layer count. - /// - internal AnimationMessage GetAnimationMessage() - { - return m_AnimationMessage; - } - - // Only used in Cleanup - private NetworkManager m_CachedNetworkManager; - - /// - public override void OnNetworkSpawn() + private void Awake() { int layers = m_Animator.layerCount; - // Initializing the below arrays for everyone handles an issue // when running in owner authoritative mode and the owner changes. m_TransitionHash = new int[layers]; m_AnimationHash = new int[layers]; m_LayerWeights = new float[layers]; - if (IsServer) - { - m_ClientSendList = new List(128); - m_ClientRpcParams = new ClientRpcParams(); - m_ClientRpcParams.Send = new ClientRpcSendParams(); - m_ClientRpcParams.Send.TargetClientIds = m_ClientSendList; - - // Cache the NetworkManager instance to remove the OnClientConnectedCallback subscription - m_CachedNetworkManager = NetworkManager; - NetworkManager.OnClientConnectedCallback += OnClientConnectedCallback; - } // We initialize the m_AnimationMessage for all instances in the event that // ownership or authority changes during runtime. m_AnimationMessage = new AnimationMessage(); @@ -612,6 +587,7 @@ public override void OnNetworkSpawn() var parameters = m_Animator.parameters; m_CachedAnimatorParameters = new NativeArray(parameters.Length, Allocator.Persistent); m_ParametersToUpdate = new List(parameters.Length); + for (var i = 0; i < parameters.Length; i++) { var parameter = parameters[i]; @@ -652,110 +628,163 @@ public override void OnNetworkSpawn() m_CachedAnimatorParameters[i] = cacheParam; } + } + + /// + /// Used for integration test to validate that the + /// AnimationMessage.AnimationStates remains the same + /// size as the layer count. + /// + internal AnimationMessage GetAnimationMessage() + { + return m_AnimationMessage; + } + + /// + public override void OnNetworkSpawn() + { + if (IsServer) + { + m_ClientSendList = new List(128); + m_ClientRpcParams = new ClientRpcParams(); + m_ClientRpcParams.Send = new ClientRpcSendParams(); + m_ClientRpcParams.Send.TargetClientIds = m_ClientSendList; + } + + // Create a handler for state changes m_NetworkAnimatorStateChangeHandler = new NetworkAnimatorStateChangeHandler(this); } /// public override void OnNetworkDespawn() { - Cleanup(); + SpawnCleanup(); } /// - /// Synchronizes newly joined players + /// Wries all parameter and state information needed to initially synchronize a client /// - internal void ServerSynchronizeNewPlayer(ulong playerId) + private void WriteSynchronizationData(ref BufferSerializer serializer) where T : IReaderWriter { - m_ClientSendList.Clear(); - m_ClientSendList.Add(playerId); - m_ClientRpcParams.Send.TargetClientIds = m_ClientSendList; - // With synchronization we send all parameters - m_ParametersToUpdate.Clear(); - for (int i = 0; i < m_CachedAnimatorParameters.Length; i++) + // Parameter synchronization { - m_ParametersToUpdate.Add(i); + // We include all parameters for the initial synchronization + m_ParametersToUpdate.Clear(); + for (int i = 0; i < m_CachedAnimatorParameters.Length; i++) + { + m_ParametersToUpdate.Add(i); + } + // Write, apply, and serialize + WriteParameters(ref m_ParameterWriter); + var parametersMessage = new ParametersUpdateMessage + { + Parameters = m_ParameterWriter.ToArray() + }; + serializer.SerializeValue(ref parametersMessage); } - SendParametersUpdate(m_ClientRpcParams); - - // Reset the dirty count before synchronizing the newly connected client with all layers - m_AnimationMessage.IsDirtyCount = 0; - for (int layer = 0; layer < m_Animator.layerCount; layer++) + // Animation state synchronization { - AnimatorStateInfo st = m_Animator.GetCurrentAnimatorStateInfo(layer); - var stateHash = st.fullPathHash; - var normalizedTime = st.normalizedTime; - var isInTransition = m_Animator.IsInTransition(layer); - - // Grab one of the available AnimationState entries so we can fill it with the current - // layer's animation state. - var animationState = m_AnimationMessage.AnimationStates[layer]; - - // Synchronizing transitions with trigger conditions for late joining clients is now - // handled by cross fading between the late joining client's current layer's AnimationState - // and the transition's destination AnimationState. - if (isInTransition) - { - var tt = m_Animator.GetAnimatorTransitionInfo(layer); - var nextState = m_Animator.GetNextAnimatorStateInfo(layer); + // Reset the dirty count before synchronizing the newly connected client with all layers + m_AnimationMessage.IsDirtyCount = 0; - if (nextState.length > 0) + for (int layer = 0; layer < m_Animator.layerCount; layer++) + { + var synchronizationStateInfo = m_Animator.GetCurrentAnimatorStateInfo(layer); + if (SynchronizationStateInfo != null) { - var nextStateTotalSpeed = nextState.speed * nextState.speedMultiplier; - var nextStateAdjustedLength = nextState.length * nextStateTotalSpeed; - // TODO: We need to get the transition curve for the target state as well as some - // reasonable RTT estimate in order to get a more precise normalized synchronization time - var transitionTime = Mathf.Min(tt.duration, tt.duration * tt.normalizedTime) * 0.5f; - normalizedTime = Mathf.Min(1.0f, transitionTime > 0.0f ? transitionTime / nextStateAdjustedLength : 0.0f); + SynchronizationStateInfo.Add(synchronizationStateInfo); } - else + var stateHash = synchronizationStateInfo.fullPathHash; + var normalizedTime = synchronizationStateInfo.normalizedTime; + var isInTransition = m_Animator.IsInTransition(layer); + + // Grab one of the available AnimationState entries so we can fill it with the current + // layer's animation state. + var animationState = m_AnimationMessage.AnimationStates[layer]; + + // Synchronizing transitions with trigger conditions for late joining clients is now + // handled by cross fading between the late joining client's current layer's AnimationState + // and the transition's destination AnimationState. + if (isInTransition) { - normalizedTime = 0.0f; - } - stateHash = nextState.fullPathHash; + var tt = m_Animator.GetAnimatorTransitionInfo(layer); + var nextState = m_Animator.GetNextAnimatorStateInfo(layer); - // Use the destination state to transition info lookup table to see if this is a transition we can - // synchronize using cross fading - if (m_DestinationStateToTransitioninfo.ContainsKey(layer)) - { - if (m_DestinationStateToTransitioninfo[layer].ContainsKey(nextState.shortNameHash)) + if (nextState.length > 0) + { + var nextStateTotalSpeed = nextState.speed * nextState.speedMultiplier; + var nextStateAdjustedLength = nextState.length * nextStateTotalSpeed; + // TODO: We need to get the transition curve for the target state as well as some + // reasonable RTT estimate in order to get a more precise normalized synchronization time + var transitionTime = Mathf.Min(tt.duration, tt.duration * tt.normalizedTime) * 0.5f; + normalizedTime = Mathf.Min(1.0f, transitionTime > 0.0f ? transitionTime / nextStateAdjustedLength : 0.0f); + } + else + { + normalizedTime = 0.0f; + } + stateHash = nextState.fullPathHash; + + // Use the destination state to transition info lookup table to see if this is a transition we can + // synchronize using cross fading + if (m_DestinationStateToTransitioninfo.ContainsKey(layer)) { - var destinationInfo = m_DestinationStateToTransitioninfo[layer][nextState.shortNameHash]; - stateHash = destinationInfo.OriginatingState; - // Set the destination state to cross fade to from the originating state - animationState.DestinationStateHash = destinationInfo.DestinationState; + if (m_DestinationStateToTransitioninfo[layer].ContainsKey(nextState.shortNameHash)) + { + var destinationInfo = m_DestinationStateToTransitioninfo[layer][nextState.shortNameHash]; + stateHash = destinationInfo.OriginatingState; + // Set the destination state to cross fade to from the originating state + animationState.DestinationStateHash = destinationInfo.DestinationState; + } } } - } - animationState.Transition = isInTransition; // The only time this could be set to true - animationState.StateHash = stateHash; // When a transition, this is the originating/starting state - animationState.NormalizedTime = normalizedTime; - animationState.Layer = layer; - animationState.Weight = m_LayerWeights[layer]; + animationState.Transition = isInTransition; // The only time this could be set to true + animationState.StateHash = stateHash; // When a transition, this is the originating/starting state + animationState.NormalizedTime = normalizedTime; + animationState.Layer = layer; + animationState.Weight = m_LayerWeights[layer]; - // Apply the changes - m_AnimationMessage.AnimationStates[layer] = animationState; + // Apply the changes + m_AnimationMessage.AnimationStates[layer] = animationState; + } + // Send all animation states + m_AnimationMessage.IsDirtyCount = m_Animator.layerCount; + m_AnimationMessage.NetworkSerialize(serializer); } - // Send all animation states - m_AnimationMessage.IsDirtyCount = m_Animator.layerCount; - SendAnimStateClientRpc(m_AnimationMessage, m_ClientRpcParams); } /// - /// Required for the server to synchronize newly joining players + /// Used to synchronize newly joined clients /// - private void OnClientConnectedCallback(ulong playerId) + protected override void OnSynchronize(ref BufferSerializer serializer) { - m_NetworkAnimatorStateChangeHandler.SynchronizeClient(playerId); + if (serializer.IsWriter) + { + WriteSynchronizationData(ref serializer); + } + else + { + var parameters = new ParametersUpdateMessage(); + var animationStates = new AnimationMessage(); + serializer.SerializeValue(ref parameters); + UpdateParameters(ref parameters); + serializer.SerializeValue(ref animationStates); + HandleAnimStateUpdate(ref animationStates); + } } /// /// Checks for changes in both Animator parameters and state. /// + /// + /// This is only invoked by clients that are the owner when not in server authoritative mode + /// or by the server itself when in server authoritative mode. + /// internal void CheckForAnimatorChanges() { - if (!IsOwner && !IsServerAuthoritative() || IsServerAuthoritative() && !IsServer) + if (!IsSpawned || (!IsOwner && !IsServerAuthoritative()) || (IsServerAuthoritative() && !IsServer)) { return; } @@ -817,6 +846,11 @@ internal void CheckForAnimatorChanges() } else { + // Just notify all remote clients and not the local server + m_ClientSendList.Clear(); + m_ClientSendList.AddRange(NetworkManager.ConnectedClientsIds); + m_ClientSendList.Remove(NetworkManager.LocalClientId); + m_ClientRpcParams.Send.TargetClientIds = m_ClientSendList; SendAnimStateClientRpc(m_AnimationMessage); } } @@ -824,10 +858,7 @@ internal void CheckForAnimatorChanges() private void SendParametersUpdate(ClientRpcParams clientRpcParams = default, bool sendDirect = false) { - m_ParameterWriter.Seek(0); - m_ParameterWriter.Truncate(); - - WriteParameters(m_ParameterWriter, sendDirect); + WriteParameters(ref m_ParameterWriter); var parametersMessage = new ParametersUpdateMessage { @@ -961,8 +992,10 @@ private bool CheckAnimStateChanged(out int stateHash, out float normalizedTime, /// This uses the m_ParametersToUpdate list to write out only /// the parameters that have changed /// - private unsafe void WriteParameters(FastBufferWriter writer, bool sendCacheState) + private unsafe void WriteParameters(ref FastBufferWriter writer) { + writer.Seek(0); + writer.Truncate(); // Write how many parameter entries we are going to write BytePacker.WriteValuePacked(writer, (uint)m_ParametersToUpdate.Count); foreach (var parameterIndex in m_ParametersToUpdate) @@ -1049,7 +1082,7 @@ private unsafe void ReadParameters(FastBufferReader reader) /// /// Applies the ParametersUpdateMessage state to the Animator /// - internal unsafe void UpdateParameters(ParametersUpdateMessage parametersUpdate) + internal unsafe void UpdateParameters(ref ParametersUpdateMessage parametersUpdate) { if (parametersUpdate.Parameters != null && parametersUpdate.Parameters.Length != 0) { @@ -1067,6 +1100,16 @@ internal unsafe void UpdateParameters(ParametersUpdateMessage parametersUpdate) /// internal void UpdateAnimationState(AnimationState animationState) { + // Handle updating layer weights first. + if (animationState.Layer < m_LayerWeights.Length) + { + if (m_LayerWeights[animationState.Layer] != animationState.Weight) + { + m_Animator.SetLayerWeight(animationState.Layer, animationState.Weight); + } + } + + // If there is no state transition then return if (animationState.StateHash == 0) { return; @@ -1114,7 +1157,6 @@ internal void UpdateAnimationState(AnimationState animationState) m_Animator.Play(animationState.StateHash, animationState.Layer, animationState.NormalizedTime); } } - m_Animator.SetLayerWeight(animationState.Layer, animationState.Weight); } /// @@ -1134,7 +1176,7 @@ private unsafe void SendParametersUpdateServerRpc(ParametersUpdateMessage parame { return; } - UpdateParameters(parametersUpdate); + UpdateParameters(ref parametersUpdate); if (NetworkManager.ConnectedClientsIds.Count > (IsHost ? 2 : 1)) { m_ClientSendList.Clear(); @@ -1183,7 +1225,6 @@ private unsafe void SendAnimStateServerRpc(AnimationMessage animationMessage, Se UpdateAnimationState(animationState); } - m_NetworkAnimatorStateChangeHandler.AddAnimationMessageToProcessQueue(animationMessage); if (NetworkManager.ConnectedClientsIds.Count > (IsHost ? 2 : 1)) { m_ClientSendList.Clear(); @@ -1196,6 +1237,18 @@ private unsafe void SendAnimStateServerRpc(AnimationMessage animationMessage, Se } } + internal void HandleAnimStateUpdate(ref AnimationMessage animationMessage) + { + var isServerAuthoritative = IsServerAuthoritative(); + if (!isServerAuthoritative && !IsOwner || isServerAuthoritative) + { + foreach (var animationState in animationMessage.AnimationStates) + { + UpdateAnimationState(animationState); + } + } + } + /// /// Internally-called RPC client receiving function to update some animation state on a client /// @@ -1211,15 +1264,7 @@ private unsafe void SendAnimStateClientRpc(AnimationMessage animationMessage, Cl } return; } - - var isServerAuthoritative = IsServerAuthoritative(); - if (!isServerAuthoritative && !IsOwner || isServerAuthoritative) - { - foreach (var animationState in animationMessage.AnimationStates) - { - UpdateAnimationState(animationState); - } - } + HandleAnimStateUpdate(ref animationMessage); } /// @@ -1319,7 +1364,7 @@ public void SetTrigger(int hash, bool setTrigger = true) m_NetworkAnimatorStateChangeHandler.QueueTriggerUpdateToClient(animTriggerMessage); if (!IsHost) { - InternalSetTrigger(hash); + InternalSetTrigger(hash, setTrigger); } } else @@ -1328,7 +1373,7 @@ public void SetTrigger(int hash, bool setTrigger = true) m_NetworkAnimatorStateChangeHandler.QueueTriggerUpdateToServer(animTriggerMessage); if (!IsServerAuthoritative()) { - InternalSetTrigger(hash); + InternalSetTrigger(hash, setTrigger); } } } diff --git a/Components/NetworkTransform.cs b/Components/NetworkTransform.cs index d9e8393..d1a08c1 100644 --- a/Components/NetworkTransform.cs +++ b/Components/NetworkTransform.cs @@ -1092,10 +1092,9 @@ private void Initialize() /// new position to move to. Can be null /// new rotation to rotate to. Can be null /// new scale to scale to. Can be null - /// Should other clients interpolate this change or not. True by default - /// new scale to scale to. Can be null + /// When true (the default) the will not be teleported and, if enabled, will interpolate. When false the will teleport/apply the parameters provided immediately. /// - public void SetState(Vector3? posIn = null, Quaternion? rotIn = null, Vector3? scaleIn = null, bool shouldGhostsInterpolate = true) + public void SetState(Vector3? posIn = null, Quaternion? rotIn = null, Vector3? scaleIn = null, bool teleportDisabled = true) { if (!IsSpawned) { @@ -1119,16 +1118,16 @@ public void SetState(Vector3? posIn = null, Quaternion? rotIn = null, Vector3? s { m_ClientIds[0] = OwnerClientId; m_ClientRpcParams.Send.TargetClientIds = m_ClientIds; - SetStateClientRpc(pos, rot, scale, !shouldGhostsInterpolate, m_ClientRpcParams); + SetStateClientRpc(pos, rot, scale, !teleportDisabled, m_ClientRpcParams); } else // Preserving the ability for server authoritative mode to accept state changes from owner { - SetStateServerRpc(pos, rot, scale, !shouldGhostsInterpolate); + SetStateServerRpc(pos, rot, scale, !teleportDisabled); } return; } - SetStateInternal(pos, rot, scale, !shouldGhostsInterpolate); + SetStateInternal(pos, rot, scale, !teleportDisabled); } /// diff --git a/Editor/AssemblyInfo.cs b/Editor/AssemblyInfo.cs index 3437d8c..f3fd38b 100644 --- a/Editor/AssemblyInfo.cs +++ b/Editor/AssemblyInfo.cs @@ -1,3 +1,7 @@ using System.Runtime.CompilerServices; +#if UNITY_INCLUDE_TESTS +#if UNITY_EDITOR [assembly: InternalsVisibleTo("Unity.Netcode.EditorTests")] +#endif // UNITY_EDITOR +#endif // UNITY_INCLUDE_TESTS diff --git a/Editor/Configuration.meta b/Editor/Configuration.meta index 1f445ad..d38b9cc 100644 --- a/Editor/Configuration.meta +++ b/Editor/Configuration.meta @@ -1,8 +1,3 @@ fileFormatVersion: 2 -guid: 52153943c346dd04e8712ab540ab9c22 -folderAsset: yes -DefaultImporter: - externalObjects: {} - userData: - assetBundleName: - assetBundleVariant: +guid: b2f70916f7024c66aa5dfe1e43c151a2 +timeCreated: 1654274400 \ No newline at end of file diff --git a/Editor/Configuration/NetcodeForGameObjectsSettings.cs b/Editor/Configuration/NetcodeForGameObjectsSettings.cs index f62b287..39ce211 100644 --- a/Editor/Configuration/NetcodeForGameObjectsSettings.cs +++ b/Editor/Configuration/NetcodeForGameObjectsSettings.cs @@ -1,9 +1,10 @@ using UnityEditor; +using UnityEngine; namespace Unity.Netcode.Editor.Configuration { - internal class NetcodeForGameObjectsSettings + internal class NetcodeForGameObjectsEditorSettings { internal const string AutoAddNetworkObjectIfNoneExists = "AutoAdd-NetworkObject-When-None-Exist"; internal const string InstallMultiplayerToolsTipDismissedPlayerPrefKey = "Netcode_Tip_InstallMPTools_Dismissed"; @@ -14,6 +15,7 @@ internal static int GetNetcodeInstallMultiplayerToolTips() { return EditorPrefs.GetInt(InstallMultiplayerToolsTipDismissedPlayerPrefKey); } + return 0; } @@ -28,6 +30,7 @@ internal static bool GetAutoAddNetworkObjectSetting() { return EditorPrefs.GetBool(AutoAddNetworkObjectIfNoneExists); } + return false; } @@ -36,4 +39,15 @@ internal static void SetAutoAddNetworkObjectSetting(bool autoAddSetting) EditorPrefs.SetBool(AutoAddNetworkObjectIfNoneExists, autoAddSetting); } } + + [FilePath("ProjectSettings/NetcodeForGameObjects.settings", FilePathAttribute.Location.ProjectFolder)] + internal class NetcodeForGameObjectsProjectSettings : ScriptableSingleton + { + [SerializeField] public bool GenerateDefaultNetworkPrefabs = true; + + internal void SaveSettings() + { + Save(true); + } + } } diff --git a/Editor/Configuration/NetcodeSettingsProvider.cs b/Editor/Configuration/NetcodeSettingsProvider.cs index c0f27ad..08bbda7 100644 --- a/Editor/Configuration/NetcodeSettingsProvider.cs +++ b/Editor/Configuration/NetcodeSettingsProvider.cs @@ -5,6 +5,11 @@ namespace Unity.Netcode.Editor.Configuration { internal static class NetcodeSettingsProvider { + private const float k_MaxLabelWidth = 450f; + private static float s_MaxLabelWidth; + private static bool s_ShowEditorSettingFields = true; + private static bool s_ShowProjectSettingFields = true; + [SettingsProvider] public static SettingsProvider CreateNetcodeSettingsProvider() { @@ -20,25 +25,105 @@ public static SettingsProvider CreateNetcodeSettingsProvider() return provider; } - internal static NetcodeSettingsLabel NetworkObjectsSectionLabel = new NetcodeSettingsLabel("NetworkObject Helper Settings", 20); - internal static NetcodeSettingsToggle AutoAddNetworkObjectToggle = new NetcodeSettingsToggle("Auto-Add NetworkObjects", "When enabled, NetworkObjects are automatically added to GameObjects when NetworkBehaviours are added first.", 20); - internal static NetcodeSettingsLabel MultiplayerToolsLabel = new NetcodeSettingsLabel("Multiplayer Tools", 20); - internal static NetcodeSettingsToggle MultiplayerToolTipStatusToggle = new NetcodeSettingsToggle("Multiplayer Tools Install Reminder", "When enabled, the NetworkManager will display " + - "the notification to install the multiplayer tools package.", 20); + + internal static NetcodeSettingsLabel NetworkObjectsSectionLabel; + internal static NetcodeSettingsToggle AutoAddNetworkObjectToggle; + internal static NetcodeSettingsLabel MultiplayerToolsLabel; + internal static NetcodeSettingsToggle MultiplayerToolTipStatusToggle; + + /// + /// Creates an instance of the settings UI Elements if they don't already exist. + /// + /// + /// We have to construct any NetcodeGUISettings derived classes here because in + /// version 2020.x.x EditorStyles.label does not exist yet (higher versions it does) + /// + private static void CheckForInitialize() + { + if (NetworkObjectsSectionLabel == null) + { + NetworkObjectsSectionLabel = new NetcodeSettingsLabel("NetworkObject Helper Settings", 20); + } + + if (AutoAddNetworkObjectToggle == null) + { + AutoAddNetworkObjectToggle = new NetcodeSettingsToggle("Auto-Add NetworkObject Component", "When enabled, NetworkObject components are automatically added to GameObjects when NetworkBehaviour components are added first.", 20); + } + + if (MultiplayerToolsLabel == null) + { + MultiplayerToolsLabel = new NetcodeSettingsLabel("Multiplayer Tools", 20); + } + + if (MultiplayerToolTipStatusToggle == null) + { + MultiplayerToolTipStatusToggle = new NetcodeSettingsToggle("Multiplayer Tools Install Reminder", "When enabled, the NetworkManager will display the notification to install the multiplayer tools package.", 20); + } + } private static void OnGuiHandler(string obj) { - var autoAddNetworkObjectSetting = NetcodeForGameObjectsSettings.GetAutoAddNetworkObjectSetting(); - var multiplayerToolsTipStatus = NetcodeForGameObjectsSettings.GetNetcodeInstallMultiplayerToolTips() == 0; + // Make sure all NetcodeGUISettings derived classes are instantiated first + CheckForInitialize(); + + var autoAddNetworkObjectSetting = NetcodeForGameObjectsEditorSettings.GetAutoAddNetworkObjectSetting(); + var multiplayerToolsTipStatus = NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() == 0; + var settings = NetcodeForGameObjectsProjectSettings.instance; + var generateDefaultPrefabs = settings.GenerateDefaultNetworkPrefabs; + EditorGUI.BeginChangeCheck(); - NetworkObjectsSectionLabel.DrawLabel(); - autoAddNetworkObjectSetting = AutoAddNetworkObjectToggle.DrawToggle(autoAddNetworkObjectSetting); - MultiplayerToolsLabel.DrawLabel(); - multiplayerToolsTipStatus = MultiplayerToolTipStatusToggle.DrawToggle(multiplayerToolsTipStatus); + + GUILayout.BeginVertical("Box"); + s_ShowEditorSettingFields = EditorGUILayout.BeginFoldoutHeaderGroup(s_ShowEditorSettingFields, "Editor Settings"); + + if (s_ShowEditorSettingFields) + { + GUILayout.BeginVertical("Box"); + NetworkObjectsSectionLabel.DrawLabel(); + autoAddNetworkObjectSetting = AutoAddNetworkObjectToggle.DrawToggle(autoAddNetworkObjectSetting); + GUILayout.EndVertical(); + + GUILayout.BeginVertical("Box"); + MultiplayerToolsLabel.DrawLabel(); + multiplayerToolsTipStatus = MultiplayerToolTipStatusToggle.DrawToggle(multiplayerToolsTipStatus); + GUILayout.EndVertical(); + } + EditorGUILayout.EndFoldoutHeaderGroup(); + GUILayout.EndVertical(); + + GUILayout.BeginVertical("Box"); + s_ShowProjectSettingFields = EditorGUILayout.BeginFoldoutHeaderGroup(s_ShowProjectSettingFields, "Project Settings"); + if (s_ShowProjectSettingFields) + { + GUILayout.BeginVertical("Box"); + const string generateNetworkPrefabsString = "Generate Default Network Prefabs List"; + + if (s_MaxLabelWidth == 0) + { + s_MaxLabelWidth = EditorStyles.label.CalcSize(new GUIContent(generateNetworkPrefabsString)).x; + s_MaxLabelWidth = Mathf.Min(k_MaxLabelWidth, s_MaxLabelWidth); + } + + EditorGUIUtility.labelWidth = s_MaxLabelWidth; + + GUILayout.Label("Network Prefabs", EditorStyles.boldLabel); + generateDefaultPrefabs = EditorGUILayout.Toggle( + new GUIContent( + generateNetworkPrefabsString, + "When enabled, a default NetworkPrefabsList object will be added to your project and kept up " + + "to date with all NetworkObject prefabs."), + generateDefaultPrefabs, + GUILayout.Width(s_MaxLabelWidth + 20)); + GUILayout.EndVertical(); + } + EditorGUILayout.EndFoldoutHeaderGroup(); + GUILayout.EndVertical(); if (EditorGUI.EndChangeCheck()) { - NetcodeForGameObjectsSettings.SetAutoAddNetworkObjectSetting(autoAddNetworkObjectSetting); - NetcodeForGameObjectsSettings.SetNetcodeInstallMultiplayerToolTips(multiplayerToolsTipStatus ? 0 : 1); + NetcodeForGameObjectsEditorSettings.SetAutoAddNetworkObjectSetting(autoAddNetworkObjectSetting); + NetcodeForGameObjectsEditorSettings.SetNetcodeInstallMultiplayerToolTips(multiplayerToolsTipStatus ? 0 : 1); + settings.GenerateDefaultNetworkPrefabs = generateDefaultPrefabs; + settings.SaveSettings(); } } } @@ -56,7 +141,7 @@ public void DrawLabel() public NetcodeSettingsLabel(string labelText, float layoutOffset = 0.0f) { m_LabelContent = labelText; - AdjustLableSize(labelText, layoutOffset); + AdjustLabelSize(labelText, layoutOffset); } } @@ -72,7 +157,7 @@ public bool DrawToggle(bool currentSetting) public NetcodeSettingsToggle(string labelText, string toolTip, float layoutOffset) { - AdjustLableSize(labelText, layoutOffset); + AdjustLabelSize(labelText, layoutOffset); m_ToggleContent = new GUIContent(labelText, toolTip); } } @@ -84,7 +169,7 @@ internal class NetcodeGUISettings protected GUILayoutOption m_LayoutWidth { get; private set; } - protected void AdjustLableSize(string labelText, float offset = 0.0f) + protected void AdjustLabelSize(string labelText, float offset = 0.0f) { m_LabelSize = Mathf.Min(k_MaxLabelWidth, EditorStyles.label.CalcSize(new GUIContent(labelText)).x); m_LayoutWidth = GUILayout.Width(m_LabelSize + offset); diff --git a/Editor/Configuration/NetworkPrefabProcessor.cs b/Editor/Configuration/NetworkPrefabProcessor.cs new file mode 100644 index 0000000..631cee1 --- /dev/null +++ b/Editor/Configuration/NetworkPrefabProcessor.cs @@ -0,0 +1,187 @@ +using System.Collections.Generic; +using UnityEditor; +using UnityEngine; + +namespace Unity.Netcode.Editor.Configuration +{ + /// + /// Updates the default instance when prefabs are updated (created, moved, deleted) in the project. + /// + public class NetworkPrefabProcessor : AssetPostprocessor + { + private static string s_DefaultNetworkPrefabsPath = "Assets/DefaultNetworkPrefabs.asset"; + public static string DefaultNetworkPrefabsPath + { + get + { + return s_DefaultNetworkPrefabsPath; + } + internal set + { + s_DefaultNetworkPrefabsPath = value; + // Force a recache of the prefab list + s_PrefabsList = null; + } + } + private static NetworkPrefabsList s_PrefabsList; + private static Dictionary s_PrefabsListPath = new Dictionary(); + + private static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths) + { + var settings = NetcodeForGameObjectsProjectSettings.instance; + if (!settings.GenerateDefaultNetworkPrefabs) + { + return; + } + + bool ProcessImportedAssets(string[] importedAssets1) + { + var dirty = false; + foreach (var assetPath in importedAssets1) + { + // We only care about GameObjects, skip everything else. Can't use the more targeted + // OnPostProcessPrefabs since that's not called for moves or deletes + if (AssetDatabase.GetMainAssetTypeAtPath(assetPath) != typeof(GameObject)) + { + continue; + } + + var go = AssetDatabase.LoadAssetAtPath(assetPath); + if (go.TryGetComponent(out _)) + { + // Make sure we are not duplicating an already existing entry + if (s_PrefabsListPath.ContainsKey(assetPath)) + { + // Is the imported asset different from the one we already have in the list? + if (s_PrefabsListPath[assetPath].Prefab.GetHashCode() != go.GetHashCode()) + { + // If so remove the one in the list and continue on to add the imported one + s_PrefabsList.List.Remove(s_PrefabsListPath[assetPath]); + } + else // If they are identical, then just ignore the import + { + continue; + } + } + + s_PrefabsList.List.Add(new NetworkPrefab { Prefab = go }); + dirty = true; + } + } + + return dirty; + } + + bool ProcessDeletedAssets(string[] strings) + { + var dirty = false; + var deleted = new List(strings); + for (int i = s_PrefabsList.List.Count - 1; i >= 0 && deleted.Count > 0; --i) + { + GameObject prefab; + try + { + prefab = s_PrefabsList.List[i].Prefab; + } + catch (MissingReferenceException) + { + s_PrefabsList.List.RemoveAt(i); + continue; + } + if (prefab == null) + { + s_PrefabsList.List.RemoveAt(i); + } + else + { + string noPath = AssetDatabase.GetAssetPath(prefab); + for (int j = strings.Length - 1; j >= 0; --j) + { + if (noPath == strings[j]) + { + s_PrefabsList.List.RemoveAt(i); + deleted.RemoveAt(j); + dirty = true; + } + } + } + } + + return dirty; + } + + if (s_PrefabsList == null) + { + s_PrefabsList = GetOrCreateNetworkPrefabs(DefaultNetworkPrefabsPath, out var newList, true); + // A new list already processed all existing assets, no need to double-process imports & deletes + if (newList) + { + return; + } + } + // Clear our asset path to prefab table each time + s_PrefabsListPath.Clear(); + + // Create our asst path to prefab table + foreach (var prefabEntry in s_PrefabsList.List) + { + if (!s_PrefabsListPath.ContainsKey(AssetDatabase.GetAssetPath(prefabEntry.Prefab))) + { + s_PrefabsListPath.Add(AssetDatabase.GetAssetPath(prefabEntry.Prefab), prefabEntry); + } + } + + // Process the imported and deleted assets + var markDirty = ProcessImportedAssets(importedAssets); + markDirty &= ProcessDeletedAssets(deletedAssets); + + if (markDirty) + { + EditorUtility.SetDirty(s_PrefabsList); + } + } + + internal static NetworkPrefabsList GetOrCreateNetworkPrefabs(string path, out bool isNew, bool addAll) + { + var defaultPrefabs = AssetDatabase.LoadAssetAtPath(path); + if (defaultPrefabs == null) + { + isNew = true; + defaultPrefabs = ScriptableObject.CreateInstance(); + defaultPrefabs.IsDefault = true; + AssetDatabase.CreateAsset(defaultPrefabs, path); + + if (addAll) + { + // This could be very expensive in large projects... maybe make it manually triggered via a menu? + defaultPrefabs.List = FindAll(); + } + EditorUtility.SetDirty(defaultPrefabs); + AssetDatabase.SaveAssetIfDirty(defaultPrefabs); + return defaultPrefabs; + } + + isNew = false; + return defaultPrefabs; + } + + private static List FindAll() + { + var list = new List(); + + string[] guids = AssetDatabase.FindAssets("t:GameObject"); + foreach (var guid in guids) + { + string assetPath = AssetDatabase.GUIDToAssetPath(guid); + var go = AssetDatabase.LoadAssetAtPath(assetPath); + + if (go.TryGetComponent(out NetworkObject _)) + { + list.Add(new NetworkPrefab { Prefab = go }); + } + } + + return list; + } + } +} diff --git a/Editor/Configuration/NetworkPrefabProcessor.cs.meta b/Editor/Configuration/NetworkPrefabProcessor.cs.meta new file mode 100644 index 0000000..ff00bdb --- /dev/null +++ b/Editor/Configuration/NetworkPrefabProcessor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d8b62a05d80cc444f9c74731c01b8e39 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: \ No newline at end of file diff --git a/Editor/Configuration/NetworkPrefabsEditor.cs b/Editor/Configuration/NetworkPrefabsEditor.cs new file mode 100644 index 0000000..0845068 --- /dev/null +++ b/Editor/Configuration/NetworkPrefabsEditor.cs @@ -0,0 +1,97 @@ +using UnityEditor; +using UnityEditorInternal; +using UnityEngine; + +namespace Unity.Netcode.Editor +{ + [CustomEditor(typeof(NetworkPrefabsList), true)] + [CanEditMultipleObjects] + public class NetworkPrefabsEditor : UnityEditor.Editor + { + private ReorderableList m_NetworkPrefabsList; + private SerializedProperty m_IsDefaultBool; + + private void OnEnable() + { + m_IsDefaultBool = serializedObject.FindProperty(nameof(NetworkPrefabsList.IsDefault)); + m_NetworkPrefabsList = new ReorderableList(serializedObject, serializedObject.FindProperty("List"), true, true, true, true); + m_NetworkPrefabsList.elementHeightCallback = index => + { + var networkOverrideInt = 0; + if (m_NetworkPrefabsList.count > 0) + { + var networkPrefab = m_NetworkPrefabsList.serializedProperty.GetArrayElementAtIndex(index); + var networkOverrideProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Override)); + networkOverrideInt = networkOverrideProp.enumValueIndex; + } + + return 8 + (networkOverrideInt == 0 ? EditorGUIUtility.singleLineHeight : (EditorGUIUtility.singleLineHeight * 2) + 5); + }; + m_NetworkPrefabsList.drawElementCallback = (rect, index, isActive, isFocused) => + { + rect.y += 5; + + var networkPrefab = m_NetworkPrefabsList.serializedProperty.GetArrayElementAtIndex(index); + var networkPrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Prefab)); + var networkSourceHashProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.SourceHashToOverride)); + var networkSourcePrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.SourcePrefabToOverride)); + var networkTargetPrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.OverridingTargetPrefab)); + var networkOverrideProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Override)); + var networkOverrideInt = networkOverrideProp.enumValueIndex; + var networkOverrideEnum = (NetworkPrefabOverride)networkOverrideInt; + EditorGUI.LabelField(new Rect(rect.x + rect.width - 70, rect.y, 60, EditorGUIUtility.singleLineHeight), "Override"); + if (networkOverrideEnum == NetworkPrefabOverride.None) + { + if (EditorGUI.Toggle(new Rect(rect.x + rect.width - 15, rect.y, 10, EditorGUIUtility.singleLineHeight), false)) + { + networkOverrideProp.enumValueIndex = (int)NetworkPrefabOverride.Prefab; + } + } + else + { + if (!EditorGUI.Toggle(new Rect(rect.x + rect.width - 15, rect.y, 10, EditorGUIUtility.singleLineHeight), true)) + { + networkOverrideProp.enumValueIndex = 0; + networkOverrideEnum = NetworkPrefabOverride.None; + } + } + + if (networkOverrideEnum == NetworkPrefabOverride.None) + { + EditorGUI.PropertyField(new Rect(rect.x, rect.y, rect.width - 80, EditorGUIUtility.singleLineHeight), networkPrefabProp, GUIContent.none); + } + else + { + networkOverrideProp.enumValueIndex = GUI.Toolbar(new Rect(rect.x, rect.y, 100, EditorGUIUtility.singleLineHeight), networkOverrideInt - 1, new[] { "Prefab", "Hash" }) + 1; + + if (networkOverrideEnum == NetworkPrefabOverride.Prefab) + { + EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 190, EditorGUIUtility.singleLineHeight), networkSourcePrefabProp, GUIContent.none); + } + else + { + EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 190, EditorGUIUtility.singleLineHeight), networkSourceHashProp, GUIContent.none); + } + + rect.y += EditorGUIUtility.singleLineHeight + 5; + + EditorGUI.LabelField(new Rect(rect.x, rect.y, 100, EditorGUIUtility.singleLineHeight), "Overriding Prefab"); + EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 110, EditorGUIUtility.singleLineHeight), networkTargetPrefabProp, GUIContent.none); + } + }; + m_NetworkPrefabsList.drawHeaderCallback = rect => EditorGUI.LabelField(rect, "NetworkPrefabs"); + } + + public override void OnInspectorGUI() + { + using (new EditorGUI.DisabledScope(true)) + { + EditorGUILayout.PropertyField(m_IsDefaultBool); + } + + m_NetworkPrefabsList.DoLayoutList(); + + serializedObject.ApplyModifiedProperties(); + } + } +} diff --git a/Editor/Configuration/NetworkPrefabsEditor.cs.meta b/Editor/Configuration/NetworkPrefabsEditor.cs.meta new file mode 100644 index 0000000..fce3467 --- /dev/null +++ b/Editor/Configuration/NetworkPrefabsEditor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8d6d0919fa8ff41c9b1d1241256f7364 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: \ No newline at end of file diff --git a/Editor/HiddenScriptEditor.cs b/Editor/HiddenScriptEditor.cs index 592580e..8e885ea 100644 --- a/Editor/HiddenScriptEditor.cs +++ b/Editor/HiddenScriptEditor.cs @@ -4,6 +4,7 @@ #endif using Unity.Netcode.Transports.UTP; using UnityEditor; +using UnityEngine; namespace Unity.Netcode.Editor { @@ -43,7 +44,109 @@ public class UNetTransportEditor : HiddenScriptEditor [CustomEditor(typeof(UnityTransport), true)] public class UnityTransportEditor : HiddenScriptEditor { + private static readonly string[] k_HiddenFields = { "m_Script", "ConnectionData" }; + private bool m_AllowIncomingConnections; + private bool m_Initialized; + + private UnityTransport m_UnityTransport; + + private SerializedProperty m_ServerAddressProperty; + private SerializedProperty m_ServerPortProperty; + private SerializedProperty m_OverrideBindIpProperty; + + private const string k_LoopbackIpv4 = "127.0.0.1"; + private const string k_LoopbackIpv6 = "::1"; + private const string k_AnyIpv4 = "0.0.0.0"; + private const string k_AnyIpv6 = "::"; + + + private void Initialize() + { + if (m_Initialized) + { + return; + } + m_Initialized = true; + m_UnityTransport = (UnityTransport)target; + + var connectionDataProperty = serializedObject.FindProperty(nameof(UnityTransport.ConnectionData)); + + m_ServerAddressProperty = connectionDataProperty.FindPropertyRelative(nameof(UnityTransport.ConnectionAddressData.Address)); + m_ServerPortProperty = connectionDataProperty.FindPropertyRelative(nameof(UnityTransport.ConnectionAddressData.Port)); + m_OverrideBindIpProperty = connectionDataProperty.FindPropertyRelative(nameof(UnityTransport.ConnectionAddressData.ServerListenAddress)); + } + + /// + /// Draws inspector properties without the script field. + /// + public override void OnInspectorGUI() + { + Initialize(); + EditorGUI.BeginChangeCheck(); + serializedObject.UpdateIfRequiredOrScript(); + DrawPropertiesExcluding(serializedObject, k_HiddenFields); + serializedObject.ApplyModifiedProperties(); + EditorGUI.EndChangeCheck(); + + EditorGUILayout.PropertyField(m_ServerAddressProperty); + EditorGUILayout.PropertyField(m_ServerPortProperty); + + serializedObject.ApplyModifiedProperties(); + + EditorGUILayout.HelpBox("It's recommended to leave remote connections disabled for local testing to avoid exposing ports on your device.", MessageType.Info); + bool allowRemoteConnections = m_UnityTransport.ConnectionData.ServerListenAddress != k_LoopbackIpv4 && m_UnityTransport.ConnectionData.ServerListenAddress != k_LoopbackIpv6 && !string.IsNullOrEmpty(m_UnityTransport.ConnectionData.ServerListenAddress); + allowRemoteConnections = EditorGUILayout.Toggle(new GUIContent("Allow Remote Connections?", $"Bind IP: {m_UnityTransport.ConnectionData.ServerListenAddress}"), allowRemoteConnections); + + bool isIpV6 = m_UnityTransport.ConnectionData.IsIpv6; + + if (!allowRemoteConnections) + { + if (m_UnityTransport.ConnectionData.ServerListenAddress != k_LoopbackIpv4 && m_UnityTransport.ConnectionData.ServerListenAddress != k_LoopbackIpv6) + { + if (isIpV6) + { + m_UnityTransport.ConnectionData.ServerListenAddress = k_LoopbackIpv6; + } + else + { + m_UnityTransport.ConnectionData.ServerListenAddress = k_LoopbackIpv4; + } + EditorUtility.SetDirty(m_UnityTransport); + } + } + + using (new EditorGUI.DisabledScope(!allowRemoteConnections)) + { + string overrideIp = m_UnityTransport.ConnectionData.ServerListenAddress; + if (overrideIp == k_AnyIpv4 || overrideIp == k_AnyIpv6 || overrideIp == k_LoopbackIpv4 || overrideIp == k_LoopbackIpv6) + { + overrideIp = ""; + } + + overrideIp = EditorGUILayout.TextField("Override Bind IP (optional)", overrideIp); + if (allowRemoteConnections) + { + if (overrideIp == "") + { + if (isIpV6) + { + overrideIp = k_AnyIpv6; + } + else + { + overrideIp = k_AnyIpv4; + } + } + + if (m_UnityTransport.ConnectionData.ServerListenAddress != overrideIp) + { + m_UnityTransport.ConnectionData.ServerListenAddress = overrideIp; + EditorUtility.SetDirty(m_UnityTransport); + } + } + } + } } #if COM_UNITY_MODULES_ANIMATION diff --git a/Editor/NetworkBehaviourEditor.cs b/Editor/NetworkBehaviourEditor.cs index 744805d..9c40d25 100644 --- a/Editor/NetworkBehaviourEditor.cs +++ b/Editor/NetworkBehaviourEditor.cs @@ -20,6 +20,7 @@ public class NetworkBehaviourEditor : UnityEditor.Editor private readonly Dictionary m_NetworkVariableObjects = new Dictionary(); private GUIContent m_NetworkVariableLabelGuiContent; + private GUIContent m_NetworkListLabelGuiContent; private void Init(MonoScript script) { @@ -30,6 +31,7 @@ private void Init(MonoScript script) m_NetworkVariableObjects.Clear(); m_NetworkVariableLabelGuiContent = new GUIContent("NetworkVariable", "This variable is a NetworkVariable. It can not be serialized and can only be changed during runtime."); + m_NetworkListLabelGuiContent = new GUIContent("NetworkList", "This variable is a NetworkList. It is rendered, but you can't serialize or change it."); var fields = script.GetClass().GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy); for (int i = 0; i < fields.Length; i++) @@ -39,6 +41,13 @@ private void Init(MonoScript script) { m_NetworkVariableNames.Add(ObjectNames.NicifyVariableName(fields[i].Name)); m_NetworkVariableFields.Add(ObjectNames.NicifyVariableName(fields[i].Name), fields[i]); + Debug.Log($"Adding NetworkVariable {fields[i].Name}"); + } + if (ft.IsGenericType && ft.GetGenericTypeDefinition() == typeof(NetworkList<>) && !fields[i].IsDefined(typeof(HideInInspector), true)) + { + m_NetworkVariableNames.Add(ObjectNames.NicifyVariableName(fields[i].Name)); + m_NetworkVariableFields.Add(ObjectNames.NicifyVariableName(fields[i].Name), fields[i]); + Debug.Log($"Adding NetworkList {fields[i].Name}"); } } } @@ -72,25 +81,48 @@ private void RenderNetworkVariable(int index) EditorGUILayout.BeginHorizontal(); if (genericType.IsValueType) { - var method = typeof(NetworkBehaviourEditor).GetMethod("RenderNetworkVariableValueType", BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.NonPublic); + var method = typeof(NetworkBehaviourEditor).GetMethod("RenderNetworkContainerValueType", BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.NonPublic); var genericMethod = method.MakeGenericMethod(genericType); genericMethod.Invoke(this, new[] { (object)index }); } else { EditorGUILayout.LabelField("Type not renderable"); + + GUILayout.Label(m_NetworkVariableLabelGuiContent, EditorStyles.miniLabel, GUILayout.Width(EditorStyles.miniLabel.CalcSize(m_NetworkVariableLabelGuiContent).x)); + EditorGUILayout.EndHorizontal(); + } + } + + private void RenderNetworkContainerValueType(int index) where T : unmanaged, IEquatable + { + try + { + var networkVariable = (NetworkVariable)m_NetworkVariableFields[m_NetworkVariableNames[index]].GetValue(target); + RenderNetworkVariableValueType(index, networkVariable); + } + catch (Exception) + { + try + { + var networkList = (NetworkList)m_NetworkVariableFields[m_NetworkVariableNames[index]].GetValue(target); + RenderNetworkListValueType(index, networkList); + } + catch (Exception e) + { + Debug.Log(e); + throw; + } } - GUILayout.Label(m_NetworkVariableLabelGuiContent, EditorStyles.miniLabel, GUILayout.Width(EditorStyles.miniLabel.CalcSize(m_NetworkVariableLabelGuiContent).x)); EditorGUILayout.EndHorizontal(); } - private void RenderNetworkVariableValueType(int index) where T : unmanaged + private void RenderNetworkVariableValueType(int index, NetworkVariable networkVariable) where T : unmanaged { - var networkVariable = (NetworkVariable)m_NetworkVariableFields[m_NetworkVariableNames[index]].GetValue(target); var type = typeof(T); object val = networkVariable.Value; - string name = m_NetworkVariableNames[index]; + string variableName = m_NetworkVariableNames[index]; var behaviour = (NetworkBehaviour)target; @@ -99,47 +131,47 @@ private void RenderNetworkVariableValueType(int index) where T : unmanaged { if (type == typeof(int)) { - val = EditorGUILayout.IntField(name, (int)val); + val = EditorGUILayout.IntField(variableName, (int)val); } else if (type == typeof(uint)) { - val = (uint)EditorGUILayout.LongField(name, (long)((uint)val)); + val = (uint)EditorGUILayout.LongField(variableName, (long)((uint)val)); } else if (type == typeof(short)) { - val = (short)EditorGUILayout.IntField(name, (int)((short)val)); + val = (short)EditorGUILayout.IntField(variableName, (int)((short)val)); } else if (type == typeof(ushort)) { - val = (ushort)EditorGUILayout.IntField(name, (int)((ushort)val)); + val = (ushort)EditorGUILayout.IntField(variableName, (int)((ushort)val)); } else if (type == typeof(sbyte)) { - val = (sbyte)EditorGUILayout.IntField(name, (int)((sbyte)val)); + val = (sbyte)EditorGUILayout.IntField(variableName, (int)((sbyte)val)); } else if (type == typeof(byte)) { - val = (byte)EditorGUILayout.IntField(name, (int)((byte)val)); + val = (byte)EditorGUILayout.IntField(variableName, (int)((byte)val)); } else if (type == typeof(long)) { - val = EditorGUILayout.LongField(name, (long)val); + val = EditorGUILayout.LongField(variableName, (long)val); } else if (type == typeof(ulong)) { - val = (ulong)EditorGUILayout.LongField(name, (long)((ulong)val)); + val = (ulong)EditorGUILayout.LongField(variableName, (long)((ulong)val)); } else if (type == typeof(bool)) { - val = EditorGUILayout.Toggle(name, (bool)val); + val = EditorGUILayout.Toggle(variableName, (bool)val); } else if (type == typeof(string)) { - val = EditorGUILayout.TextField(name, (string)val); + val = EditorGUILayout.TextField(variableName, (string)val); } else if (type.IsEnum) { - val = EditorGUILayout.EnumPopup(name, (Enum)val); + val = EditorGUILayout.EnumPopup(variableName, (Enum)val); } else { @@ -150,11 +182,31 @@ private void RenderNetworkVariableValueType(int index) where T : unmanaged } else { - EditorGUILayout.LabelField(name, EditorStyles.wordWrappedLabel); + EditorGUILayout.LabelField(variableName, EditorStyles.wordWrappedLabel); EditorGUILayout.SelectableLabel(val.ToString(), EditorStyles.wordWrappedLabel); } + GUILayout.Label(m_NetworkVariableLabelGuiContent, EditorStyles.miniLabel, GUILayout.Width(EditorStyles.miniLabel.CalcSize(m_NetworkVariableLabelGuiContent).x)); } + private void RenderNetworkListValueType(int index, NetworkList networkList) + where T : unmanaged, IEquatable + { + string variableName = m_NetworkVariableNames[index]; + + string value = ""; + bool addComma = false; + foreach (var v in networkList) + { + if (addComma) + { + value += ", "; + } + value += v.ToString(); + addComma = true; + } + EditorGUILayout.LabelField(variableName, value); + GUILayout.Label(m_NetworkListLabelGuiContent, EditorStyles.miniLabel, GUILayout.Width(EditorStyles.miniLabel.CalcSize(m_NetworkListLabelGuiContent).x)); + } /// public override void OnInspectorGUI() @@ -310,7 +362,7 @@ public static void CheckForNetworkObject(GameObject gameObject, bool networkObje // and the user has already turned "Auto-Add NetworkObject" on when first notified about the requirement // then just send a reminder to the user why the NetworkObject they just deleted seemingly "re-appeared" // again. - if (networkObjectRemoved && NetcodeForGameObjectsSettings.GetAutoAddNetworkObjectSetting()) + if (networkObjectRemoved && NetcodeForGameObjectsEditorSettings.GetAutoAddNetworkObjectSetting()) { Debug.LogWarning($"{gameObject.name} still has {nameof(NetworkBehaviour)}s and Auto-Add NetworkObjects is enabled. A NetworkObject is being added back to {gameObject.name}."); Debug.Log($"To reset Auto-Add NetworkObjects: Select the Netcode->General->Reset Auto-Add NetworkObject menu item."); @@ -319,7 +371,7 @@ public static void CheckForNetworkObject(GameObject gameObject, bool networkObje // Notify and provide the option to add it one time, always add a NetworkObject, or do nothing and let the user manually add it if (EditorUtility.DisplayDialog($"{nameof(NetworkBehaviour)}s require a {nameof(NetworkObject)}", $"{gameObject.name} does not have a {nameof(NetworkObject)} component. Would you like to add one now?", "Yes", "No (manually add it)", - DialogOptOutDecisionType.ForThisMachine, NetcodeForGameObjectsSettings.AutoAddNetworkObjectIfNoneExists)) + DialogOptOutDecisionType.ForThisMachine, NetcodeForGameObjectsEditorSettings.AutoAddNetworkObjectIfNoneExists)) { gameObject.AddComponent(); var activeScene = UnityEngine.SceneManagement.SceneManager.GetActiveScene(); diff --git a/Editor/NetworkManagerEditor.cs b/Editor/NetworkManagerEditor.cs index d79cd9c..bcf8365 100644 --- a/Editor/NetworkManagerEditor.cs +++ b/Editor/NetworkManagerEditor.cs @@ -1,8 +1,8 @@ using System; using System.Collections.Generic; +using System.IO; using UnityEditor; using UnityEngine; -using UnityEditorInternal; using Unity.Netcode.Editor.Configuration; namespace Unity.Netcode.Editor @@ -40,8 +40,7 @@ public class NetworkManagerEditor : UnityEditor.Editor private SerializedProperty m_NetworkIdRecycleDelayProperty; private SerializedProperty m_RpcHashSizeProperty; private SerializedProperty m_LoadSceneTimeOutProperty; - - private ReorderableList m_NetworkPrefabsList; + private SerializedProperty m_PrefabsList; private NetworkManager m_NetworkManager; private bool m_Initialized; @@ -106,7 +105,9 @@ private void Initialize() m_NetworkIdRecycleDelayProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkIdRecycleDelay"); m_RpcHashSizeProperty = m_NetworkConfigProperty.FindPropertyRelative("RpcHashSize"); m_LoadSceneTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("LoadSceneTimeOut"); - + m_PrefabsList = m_NetworkConfigProperty + .FindPropertyRelative(nameof(NetworkConfig.Prefabs)) + .FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists)); ReloadTransports(); } @@ -132,76 +133,9 @@ private void CheckNullProperties() m_NetworkIdRecycleDelayProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkIdRecycleDelay"); m_RpcHashSizeProperty = m_NetworkConfigProperty.FindPropertyRelative("RpcHashSize"); m_LoadSceneTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("LoadSceneTimeOut"); - } - - private void OnEnable() - { - m_NetworkPrefabsList = new ReorderableList(serializedObject, serializedObject.FindProperty(nameof(NetworkManager.NetworkConfig)).FindPropertyRelative(nameof(NetworkConfig.NetworkPrefabs)), true, true, true, true); - m_NetworkPrefabsList.elementHeightCallback = index => - { - var networkOverrideInt = 0; - if (m_NetworkPrefabsList.count > 0) - { - var networkPrefab = m_NetworkPrefabsList.serializedProperty.GetArrayElementAtIndex(index); - var networkOverrideProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Override)); - networkOverrideInt = networkOverrideProp.enumValueIndex; - } - - return 8 + (networkOverrideInt == 0 ? EditorGUIUtility.singleLineHeight : (EditorGUIUtility.singleLineHeight * 2) + 5); - }; - m_NetworkPrefabsList.drawElementCallback = (rect, index, isActive, isFocused) => - { - rect.y += 5; - - var networkPrefab = m_NetworkPrefabsList.serializedProperty.GetArrayElementAtIndex(index); - var networkPrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Prefab)); - var networkSourceHashProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.SourceHashToOverride)); - var networkSourcePrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.SourcePrefabToOverride)); - var networkTargetPrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.OverridingTargetPrefab)); - var networkOverrideProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Override)); - var networkOverrideInt = networkOverrideProp.enumValueIndex; - var networkOverrideEnum = (NetworkPrefabOverride)networkOverrideInt; - EditorGUI.LabelField(new Rect(rect.x + rect.width - 70, rect.y, 60, EditorGUIUtility.singleLineHeight), "Override"); - if (networkOverrideEnum == NetworkPrefabOverride.None) - { - if (EditorGUI.Toggle(new Rect(rect.x + rect.width - 15, rect.y, 10, EditorGUIUtility.singleLineHeight), false)) - { - networkOverrideProp.enumValueIndex = (int)NetworkPrefabOverride.Prefab; - } - } - else - { - if (!EditorGUI.Toggle(new Rect(rect.x + rect.width - 15, rect.y, 10, EditorGUIUtility.singleLineHeight), true)) - { - networkOverrideProp.enumValueIndex = 0; - networkOverrideEnum = NetworkPrefabOverride.None; - } - } - - if (networkOverrideEnum == NetworkPrefabOverride.None) - { - EditorGUI.PropertyField(new Rect(rect.x, rect.y, rect.width - 80, EditorGUIUtility.singleLineHeight), networkPrefabProp, GUIContent.none); - } - else - { - networkOverrideProp.enumValueIndex = GUI.Toolbar(new Rect(rect.x, rect.y, 100, EditorGUIUtility.singleLineHeight), networkOverrideInt - 1, new[] { "Prefab", "Hash" }) + 1; - - if (networkOverrideEnum == NetworkPrefabOverride.Prefab) - { - EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 190, EditorGUIUtility.singleLineHeight), networkSourcePrefabProp, GUIContent.none); - } - else - { - EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 190, EditorGUIUtility.singleLineHeight), networkSourceHashProp, GUIContent.none); - } - - rect.y += EditorGUIUtility.singleLineHeight + 5; - - EditorGUI.LabelField(new Rect(rect.x, rect.y, 100, EditorGUIUtility.singleLineHeight), "Overriding Prefab"); - EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 110, EditorGUIUtility.singleLineHeight), networkTargetPrefabProp, GUIContent.none); - } - }; - m_NetworkPrefabsList.drawHeaderCallback = rect => EditorGUI.LabelField(rect, "NetworkPrefabs"); + m_PrefabsList = m_NetworkConfigProperty + .FindPropertyRelative(nameof(NetworkConfig.Prefabs)) + .FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists)); } /// @@ -224,7 +158,62 @@ public override void OnInspectorGUI() EditorGUILayout.PropertyField(m_PlayerPrefabProperty); EditorGUILayout.Space(); - m_NetworkPrefabsList.DoLayoutList(); + 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); @@ -359,7 +348,7 @@ private static void DrawInstallMultiplayerToolsTip() const string targetUrl = "https://docs-multiplayer.unity3d.com/netcode/current/tools/install-tools"; const string infoIconName = "console.infoicon"; - if (NetcodeForGameObjectsSettings.GetNetcodeInstallMultiplayerToolTips() != 0) + if (NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() != 0) { return; } @@ -405,7 +394,7 @@ private static void DrawInstallMultiplayerToolsTip() GUILayout.FlexibleSpace(); if (GUILayout.Button(dismissButtonText, dismissButtonStyle, GUILayout.ExpandWidth(false))) { - NetcodeForGameObjectsSettings.SetNetcodeInstallMultiplayerToolTips(1); + NetcodeForGameObjectsEditorSettings.SetNetcodeInstallMultiplayerToolTips(1); } EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link); GUILayout.FlexibleSpace(); diff --git a/Editor/NetworkManagerHelper.cs b/Editor/NetworkManagerHelper.cs index c7d13b0..6fd6103 100644 --- a/Editor/NetworkManagerHelper.cs +++ b/Editor/NetworkManagerHelper.cs @@ -1,5 +1,6 @@ using System.Collections.Generic; using System.Linq; +using Unity.Netcode.Editor.Configuration; using UnityEngine; using UnityEngine.SceneManagement; using UnityEditor; @@ -32,6 +33,24 @@ private static void InitializeOnload() EditorApplication.playModeStateChanged += EditorApplication_playModeStateChanged; EditorApplication.hierarchyChanged += EditorApplication_hierarchyChanged; + + // Initialize default values for new NetworkManagers + // + // When the default prefab list is enabled, this will default + // new NetworkManagers to using it. + // + // This will get run when new NetworkManagers are added, and + // when the user presses the "reset" button on a NetworkManager + // in the inspector. + NetworkManager.OnNetworkManagerReset = manager => + { + var settings = NetcodeForGameObjectsProjectSettings.instance; + if (settings.GenerateDefaultNetworkPrefabs) + { + manager.NetworkConfig = new NetworkConfig(); + manager.NetworkConfig.Prefabs.NetworkPrefabsLists = new List { NetworkPrefabProcessor.GetOrCreateNetworkPrefabs(NetworkPrefabProcessor.DefaultNetworkPrefabsPath, out _, true) }; + } + }; } private static void EditorApplication_playModeStateChanged(PlayModeStateChange playModeStateChange) diff --git a/Runtime/AssemblyInfo.cs b/Runtime/AssemblyInfo.cs index 935d273..134b912 100644 --- a/Runtime/AssemblyInfo.cs +++ b/Runtime/AssemblyInfo.cs @@ -1,15 +1,25 @@ using System.Runtime.CompilerServices; #if UNITY_EDITOR -[assembly: InternalsVisibleTo("Unity.Netcode.EditorTests")] -[assembly: InternalsVisibleTo("Unity.Netcode.Editor.CodeGen")] [assembly: InternalsVisibleTo("Unity.Netcode.Editor")] -[assembly: InternalsVisibleTo("TestProject.EditorTests")] [assembly: InternalsVisibleTo("Unity.Netcode.Editor.CodeGen")] -#endif -[assembly: InternalsVisibleTo("TestProject.ToolsIntegration.RuntimeTests")] -[assembly: InternalsVisibleTo("TestProject.RuntimeTests")] +#endif // UNITY_EDITOR +#if MULTIPLAYER_TOOLS +[assembly: InternalsVisibleTo("Unity.Multiplayer.Tools.Adapters.Ngo1WithUtp2")] +#endif // MULTIPLAYER_TOOLS +#if COM_UNITY_NETCODE_ADAPTER_UTP +[assembly: InternalsVisibleTo("Unity.Netcode.Adapter.UTP")] +#endif // COM_UNITY_NETCODE_ADAPTER_UTP + +#if UNITY_INCLUDE_TESTS [assembly: InternalsVisibleTo("Unity.Netcode.RuntimeTests")] [assembly: InternalsVisibleTo("Unity.Netcode.TestHelpers.Runtime")] -[assembly: InternalsVisibleTo("Unity.Netcode.Adapter.UTP")] -[assembly: InternalsVisibleTo("Unity.Multiplayer.Tools.Adapters.Ngo1WithUtp2")] +[assembly: InternalsVisibleTo("TestProject.RuntimeTests")] +#if UNITY_EDITOR +[assembly: InternalsVisibleTo("Unity.Netcode.EditorTests")] +[assembly: InternalsVisibleTo("TestProject.EditorTests")] +#endif // UNITY_EDITOR +#if MULTIPLAYER_TOOLS +[assembly: InternalsVisibleTo("TestProject.ToolsIntegration.RuntimeTests")] +#endif // MULTIPLAYER_TOOLS +#endif // UNITY_INCLUDE_TESTS diff --git a/Runtime/Configuration/NetworkConfig.cs b/Runtime/Configuration/NetworkConfig.cs index 7c01888..23ff460 100644 --- a/Runtime/Configuration/NetworkConfig.cs +++ b/Runtime/Configuration/NetworkConfig.cs @@ -3,6 +3,7 @@ using UnityEngine; using System.Linq; using Unity.Collections; +using UnityEngine.Serialization; namespace Unity.Netcode { @@ -30,20 +31,8 @@ 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; - /// - /// A list of prefabs that can be dynamically spawned. - /// [SerializeField] - [Tooltip("The prefabs that can be spawned across the network")] - internal List NetworkPrefabs = new List(); - - /// - /// This dictionary provides a quick way to check and see if a NetworkPrefab has a NetworkPrefab override. - /// Generated at runtime and OnValidate - /// - internal Dictionary NetworkPrefabOverrideLinks = new Dictionary(); - - internal Dictionary OverrideToNetworkPrefab = new Dictionary(); + public NetworkPrefabs Prefabs = new NetworkPrefabs(); /// @@ -239,7 +228,7 @@ public ulong GetConfig(bool cache = true) if (ForceSamePrefabs) { - var sortedDictionary = NetworkPrefabOverrideLinks.OrderBy(x => x.Key); + var sortedDictionary = Prefabs.NetworkPrefabOverrideLinks.OrderBy(x => x.Key); foreach (var sortedEntry in sortedDictionary) { @@ -273,6 +262,79 @@ public bool CompareConfig(ulong hash) { return hash == GetConfig(); } + + internal void InitializePrefabs() + { + if (HasOldPrefabList()) + { + MigrateOldNetworkPrefabsToNetworkPrefabsList(); + } + + Prefabs.Initialize(); + } + + #region Legacy Network Prefab List + + [NonSerialized] + private bool m_DidWarnOldPrefabList = false; + + private void WarnOldPrefabList() + { + if (!m_DidWarnOldPrefabList) + { + Debug.LogWarning("Using Legacy Network Prefab List. Consider Migrating."); + m_DidWarnOldPrefabList = true; + } + } + + /// + /// Returns true if the old List<NetworkPrefab> serialized data is present. + /// + /// + /// Internal use only to help migrate projects. + internal bool HasOldPrefabList() + { + return OldPrefabList?.Count > 0; + } + + /// + /// Migrate the old format List<NetworkPrefab> prefab registration to the new NetworkPrefabsList ScriptableObject. + /// + /// + /// OnAfterDeserialize cannot instantiate new objects (e.g. NetworkPrefabsList SO) since it executes in a thread, so we have to do it later. + /// Since NetworkConfig isn't a Unity.Object it doesn't get an Awake callback, so we have to do this in NetworkManager and expose this API. + /// + internal NetworkPrefabsList MigrateOldNetworkPrefabsToNetworkPrefabsList() + { + if (OldPrefabList == null || OldPrefabList.Count == 0) + { + return null; + } + + if (Prefabs == null) + { + throw new Exception("Prefabs field is null."); + } + + Prefabs.NetworkPrefabsLists.Add(ScriptableObject.CreateInstance()); + + if (OldPrefabList?.Count > 0) + { + // Migrate legacy types/fields + foreach (var networkPrefab in OldPrefabList) + { + Prefabs.NetworkPrefabsLists[Prefabs.NetworkPrefabsLists.Count - 1].Add(networkPrefab); + } + } + + OldPrefabList = null; + return Prefabs.NetworkPrefabsLists[Prefabs.NetworkPrefabsLists.Count - 1]; + } + + [FormerlySerializedAs("NetworkPrefabs")] + [SerializeField] + internal List OldPrefabList; + + #endregion } } - diff --git a/Runtime/Configuration/NetworkPrefab.cs b/Runtime/Configuration/NetworkPrefab.cs index cc22258..dbb1d91 100644 --- a/Runtime/Configuration/NetworkPrefab.cs +++ b/Runtime/Configuration/NetworkPrefab.cs @@ -3,10 +3,23 @@ namespace Unity.Netcode { - internal enum NetworkPrefabOverride + /// + /// The method of NetworkPrefab override used to identify the source prefab + /// + public enum NetworkPrefabOverride { + /// + /// No oeverride is present + /// None, + /// + /// Override the prefab when the given SourcePrefabToOverride is requested + /// Prefab, + /// + /// Override the prefab when the given SourceHashToOverride is requested + /// Used in situations where the server assets do not exist in client builds + /// Hash } @@ -14,10 +27,10 @@ internal enum NetworkPrefabOverride /// Class that represents a NetworkPrefab /// [Serializable] - internal class NetworkPrefab + public class NetworkPrefab { /// - /// The override setttings for this NetworkPrefab + /// The override settings for this NetworkPrefab /// public NetworkPrefabOverride Override; @@ -41,5 +54,168 @@ internal class NetworkPrefab /// The prefab to replace (override) the source prefab with /// public GameObject OverridingTargetPrefab; + + public bool Equals(NetworkPrefab other) + { + return Override == other.Override && + Prefab == other.Prefab && + SourcePrefabToOverride == other.SourcePrefabToOverride && + SourceHashToOverride == other.SourceHashToOverride && + OverridingTargetPrefab == other.OverridingTargetPrefab; + } + + public uint SourcePrefabGlobalObjectIdHash + { + get + { + switch (Override) + { + case NetworkPrefabOverride.None: + if (Prefab != null && Prefab.TryGetComponent(out NetworkObject no)) + { + return no.GlobalObjectIdHash; + } + + throw new InvalidOperationException("Prefab field isn't set or isn't a Network Object"); + case NetworkPrefabOverride.Prefab: + if (SourcePrefabToOverride != null && SourcePrefabToOverride.TryGetComponent(out no)) + { + return no.GlobalObjectIdHash; + } + + throw new InvalidOperationException("Source Prefab field isn't set or isn't a Network Object"); + case NetworkPrefabOverride.Hash: + return SourceHashToOverride; + default: + throw new ArgumentOutOfRangeException(); + } + } + } + + public uint TargetPrefabGlobalObjectIdHash + { + get + { + switch (Override) + { + case NetworkPrefabOverride.None: + return 0; + case NetworkPrefabOverride.Prefab: + case NetworkPrefabOverride.Hash: + if (OverridingTargetPrefab != null && OverridingTargetPrefab.TryGetComponent(out NetworkObject no)) + { + return no.GlobalObjectIdHash; + } + + throw new InvalidOperationException("Target Prefab field isn't set or isn't a Network Object"); + default: + throw new ArgumentOutOfRangeException(); + } + } + } + + public bool Validate(int index = -1) + { + NetworkObject networkObject; + if (Override == NetworkPrefabOverride.None) + { + if (Prefab == null) + { + NetworkLog.LogWarning($"{nameof(NetworkPrefab)} cannot be null ({nameof(NetworkPrefab)} at index: {index})"); + return false; + } + + networkObject = Prefab.GetComponent(); + if (networkObject == null) + { + if (NetworkLog.CurrentLogLevel <= LogLevel.Error) + { + NetworkLog.LogWarning($"{NetworkManager.PrefabDebugHelper(this)} is missing " + + $"a {nameof(NetworkObject)} component (entry will be ignored)."); + } + return false; + } + + return true; + } + + // Validate source prefab override values first + switch (Override) + { + case NetworkPrefabOverride.Hash: + { + if (SourceHashToOverride == 0) + { + if (NetworkLog.CurrentLogLevel <= LogLevel.Error) + { + NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(SourceHashToOverride)} is zero " + + "(entry will be ignored)."); + } + return false; + } + + break; + } + case NetworkPrefabOverride.Prefab: + { + if (SourcePrefabToOverride == null) + { + // This is a leftover side-effect from NetworkManager's OnValidate. It's a usability + // adjustment to automatically set the "Prefab" field as the source prefab when a user + // swaps from the default Inspector to the override one. + if (Prefab != null) + { + SourcePrefabToOverride = Prefab; + } + else if (NetworkLog.CurrentLogLevel <= LogLevel.Error) + { + NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(SourcePrefabToOverride)} is null (entry will be ignored)."); + return false; + } + } + + if (!SourcePrefabToOverride.TryGetComponent(out networkObject)) + { + if (NetworkLog.CurrentLogLevel <= LogLevel.Error) + { + NetworkLog.LogWarning($"{nameof(NetworkPrefab)} ({SourcePrefabToOverride.name}) " + + $"is missing a {nameof(NetworkObject)} component (entry will be ignored)."); + } + return false; + } + + break; + } + } + + // Validate target prefab override values next + if (OverridingTargetPrefab == null) + { + if (NetworkLog.CurrentLogLevel <= LogLevel.Error) + { + NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(OverridingTargetPrefab)} is null!"); + } + switch (Override) + { + case NetworkPrefabOverride.Hash: + { + Debug.LogWarning($"{nameof(NetworkPrefab)} override entry {SourceHashToOverride} will be removed and ignored."); + break; + } + case NetworkPrefabOverride.Prefab: + { + Debug.LogWarning($"{nameof(NetworkPrefab)} override entry ({SourcePrefabToOverride.name}) will be removed and ignored."); + break; + } + } + return false; + } + return true; + } + + public override string ToString() + { + return $"{{SourceHash: {SourceHashToOverride}, TargetHash: {TargetPrefabGlobalObjectIdHash}}}"; + } } } diff --git a/Runtime/Configuration/NetworkPrefabs.cs b/Runtime/Configuration/NetworkPrefabs.cs new file mode 100644 index 0000000..6c2d526 --- /dev/null +++ b/Runtime/Configuration/NetworkPrefabs.cs @@ -0,0 +1,297 @@ +using System; +using System.Collections.Generic; +using System.Text; +using UnityEngine; + +namespace Unity.Netcode +{ + /// + /// A class that represents the runtime aspect of network prefabs. + /// This class contains processed prefabs from the NetworkPrefabsList, as + /// well as additional modifications (additions and removals) made at runtime. + /// + [Serializable] + public class NetworkPrefabs + { + /// + /// Edit-time scripted object containing a list of NetworkPrefabs. + /// + /// + /// This field can be null if no prefabs are pre-configured. + /// Runtime usages of should not depend on this edit-time field for execution. + /// + [SerializeField] + public List NetworkPrefabsLists = new List(); + + /// + /// This dictionary provides a quick way to check and see if a NetworkPrefab has a NetworkPrefab override. + /// Generated at runtime and OnValidate + /// + [NonSerialized] + public Dictionary NetworkPrefabOverrideLinks = new Dictionary(); + + [NonSerialized] + public Dictionary OverrideToNetworkPrefab = new Dictionary(); + + public IReadOnlyList Prefabs => m_Prefabs; + + [NonSerialized] + private List m_Prefabs = new List(); + + private void AddTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab) + { + if (AddPrefabRegistration(networkPrefab)) + { + m_Prefabs.Add(networkPrefab); + } + } + + private void RemoveTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab) + { + m_Prefabs.Remove(networkPrefab); + } + + ~NetworkPrefabs() + { + foreach (var list in NetworkPrefabsLists) + { + list.OnAdd -= AddTriggeredByNetworkPrefabList; + list.OnRemove -= RemoveTriggeredByNetworkPrefabList; + } + } + + /// + /// Processes the if one is present for use during runtime execution, + /// else processes . + /// + public void Initialize(bool warnInvalid = true) + { + if (NetworkPrefabsLists.Count != 0 && m_Prefabs.Count > 0) + { + NetworkLog.LogWarning("Runtime Network Prefabs was not empty at initialization time. Network " + + "Prefab registrations made before initialization will be replaced by NetworkPrefabsList."); + m_Prefabs.Clear(); + } + + foreach (var list in NetworkPrefabsLists) + { + list.OnAdd += AddTriggeredByNetworkPrefabList; + list.OnRemove += RemoveTriggeredByNetworkPrefabList; + } + + NetworkPrefabOverrideLinks.Clear(); + OverrideToNetworkPrefab.Clear(); + + var prefabs = NetworkPrefabsLists.Count != 0 ? new List() : m_Prefabs; + + if (NetworkPrefabsLists.Count != 0) + { + foreach (var list in NetworkPrefabsLists) + { + foreach (var networkPrefab in list.PrefabList) + { + prefabs.Add(networkPrefab); + } + } + } + + m_Prefabs = new List(); + + List removeList = null; + if (warnInvalid) + { + removeList = new List(); + } + + foreach (var networkPrefab in prefabs) + { + if (AddPrefabRegistration(networkPrefab)) + { + m_Prefabs.Add(networkPrefab); + } + else + { + removeList?.Add(networkPrefab); + } + } + + // Clear out anything that is invalid or not used + if (removeList?.Count > 0) + { + if (NetworkLog.CurrentLogLevel <= LogLevel.Error) + { + var sb = new StringBuilder("Removing invalid prefabs from Network Prefab registration: "); + sb.Append(string.Join(", ", removeList)); + NetworkLog.LogWarning(sb.ToString()); + } + } + } + + /// + /// Add a new NetworkPrefab instance to the list + /// + /// + /// The framework does not synchronize this list between clients. Any runtime changes must be handled manually. + /// + /// Any modifications made here are not persisted. Permanent configuration changes should be done + /// through the scriptable object property. + /// + public bool Add(NetworkPrefab networkPrefab) + { + if (AddPrefabRegistration(networkPrefab)) + { + m_Prefabs.Add(networkPrefab); + return true; + } + + return false; + } + + /// + /// Remove a NetworkPrefab instance from the list + /// + /// + /// The framework does not synchronize this list between clients. Any runtime changes must be handled manually. + /// + /// Any modifications made here are not persisted. Permanent configuration changes should be done + /// through the scriptable object property. + /// + public void Remove(NetworkPrefab prefab) + { + if (prefab == null) + { + throw new ArgumentNullException(nameof(prefab)); + } + + m_Prefabs.Remove(prefab); + OverrideToNetworkPrefab.Remove(prefab.TargetPrefabGlobalObjectIdHash); + NetworkPrefabOverrideLinks.Remove(prefab.SourcePrefabGlobalObjectIdHash); + } + + /// + /// Remove a NetworkPrefab instance with matching from the list + /// + /// + /// The framework does not synchronize this list between clients. Any runtime changes must be handled manually. + /// + /// Any modifications made here are not persisted. Permanent configuration changes should be done + /// through the scriptable object property. + /// + public void Remove(GameObject prefab) + { + if (prefab == null) + { + throw new ArgumentNullException(nameof(prefab)); + } + + for (int i = 0; i < m_Prefabs.Count; i++) + { + if (m_Prefabs[i].Prefab == prefab) + { + Remove(m_Prefabs[i]); + return; + } + } + } + + /// + /// Check if the given GameObject is present as a prefab within the list + /// + /// The prefab to check + /// Whether or not the prefab exists + public bool Contains(GameObject prefab) + { + for (int i = 0; i < m_Prefabs.Count; i++) + { + if (m_Prefabs[i].Prefab == prefab) + { + return true; + } + } + + return false; + } + + /// + /// Check if the given NetworkPrefab is present within the list + /// + /// The prefab to check + /// Whether or not the prefab exists + public bool Contains(NetworkPrefab prefab) + { + for (int i = 0; i < m_Prefabs.Count; i++) + { + if (m_Prefabs[i].Equals(prefab)) + { + return true; + } + } + + return false; + } + + /// + /// Configures and for the given + /// + private bool AddPrefabRegistration(NetworkPrefab networkPrefab) + { + if (networkPrefab == null) + { + return false; + } + // Safeguard validation check since this method is called from outside of NetworkConfig and we can't control what's passed in. + if (!networkPrefab.Validate()) + { + return false; + } + + uint source = networkPrefab.SourcePrefabGlobalObjectIdHash; + uint target = networkPrefab.TargetPrefabGlobalObjectIdHash; + + // Make sure the prefab isn't already registered. + if (NetworkPrefabOverrideLinks.ContainsKey(source)) + { + var networkObject = networkPrefab.Prefab.GetComponent(); + + // This should never happen, but in the case it somehow does log an error and remove the duplicate entry + Debug.LogError($"{nameof(NetworkPrefab)} ({networkObject.name}) has a duplicate {nameof(NetworkObject.GlobalObjectIdHash)} source entry value of: {source}!"); + return false; + } + + // If we don't have an override configured, registration is simple! + if (networkPrefab.Override == NetworkPrefabOverride.None) + { + NetworkPrefabOverrideLinks.Add(source, networkPrefab); + 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(); + + // 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); + } + break; + } + + return true; + } + } +} diff --git a/Runtime/Configuration/NetworkPrefabs.cs.meta b/Runtime/Configuration/NetworkPrefabs.cs.meta new file mode 100644 index 0000000..ccd14a5 --- /dev/null +++ b/Runtime/Configuration/NetworkPrefabs.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 230fc75f5639e46dc91734aa67d56a3e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: \ No newline at end of file diff --git a/Runtime/Configuration/NetworkPrefabsList.cs b/Runtime/Configuration/NetworkPrefabsList.cs new file mode 100644 index 0000000..1c47191 --- /dev/null +++ b/Runtime/Configuration/NetworkPrefabsList.cs @@ -0,0 +1,95 @@ +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Serialization; + +namespace Unity.Netcode +{ + /// + /// A ScriptableObject for holding a network prefabs list, which can be + /// shared between multiple NetworkManagers. + /// + /// When NetworkManagers hold references to this list, modifications to the + /// list at runtime will be picked up by all NetworkManagers that reference it. + /// + [CreateAssetMenu(fileName = "NetworkPrefabsList", menuName = "Netcode/Network Prefabs List")] + public class NetworkPrefabsList : ScriptableObject + { + internal delegate void OnAddDelegate(NetworkPrefab prefab); + internal OnAddDelegate OnAdd; + + internal delegate void OnRemoveDelegate(NetworkPrefab prefab); + internal OnRemoveDelegate OnRemove; + + [SerializeField] + internal bool IsDefault; + + [FormerlySerializedAs("Prefabs")] + [SerializeField] + internal List List = new List(); + + /// + /// Read-only view into the prefabs list, enabling iterating and examining the list. + /// Actually modifying the list should be done using + /// and . + /// + public IReadOnlyList PrefabList => List; + + /// + /// Adds a prefab to the prefab list. Performing this here will apply the operation to all + /// s that reference this list. + /// + /// + public void Add(NetworkPrefab prefab) + { + List.Add(prefab); + OnAdd?.Invoke(prefab); + } + + /// + /// Removes a prefab from the prefab list. Performing this here will apply the operation to all + /// s that reference this list. + /// + /// + public void Remove(NetworkPrefab prefab) + { + List.Remove(prefab); + OnRemove?.Invoke(prefab); + } + + /// + /// Check if the given GameObject is present as a prefab within the list + /// + /// The prefab to check + /// Whether or not the prefab exists + public bool Contains(GameObject prefab) + { + for (int i = 0; i < List.Count; i++) + { + if (List[i].Prefab == prefab) + { + return true; + } + } + + return false; + } + + /// + /// Check if the given NetworkPrefab is present within the list + /// + /// The prefab to check + /// Whether or not the prefab exists + public bool Contains(NetworkPrefab prefab) + { + for (int i = 0; i < List.Count; i++) + { + if (List[i].Equals(prefab)) + { + return true; + } + } + + return false; + } + } +} diff --git a/Runtime/Configuration/NetworkPrefabsList.cs.meta b/Runtime/Configuration/NetworkPrefabsList.cs.meta new file mode 100644 index 0000000..7cb781b --- /dev/null +++ b/Runtime/Configuration/NetworkPrefabsList.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e651dbb3fbac04af2b8f5abf007ddc23 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: \ No newline at end of file diff --git a/Runtime/Core/NetworkBehaviour.cs b/Runtime/Core/NetworkBehaviour.cs index 1a43947..b532a78 100644 --- a/Runtime/Core/NetworkBehaviour.cs +++ b/Runtime/Core/NetworkBehaviour.cs @@ -314,18 +314,18 @@ public NetworkManager NetworkManager /// /// Gets if we are executing as server /// - protected bool IsServer { get; private set; } + public bool IsServer { get; private set; } /// /// Gets if we are executing as client /// - protected bool IsClient { get; private set; } + public bool IsClient { get; private set; } /// /// Gets if we are executing as Host, I.E Server and Client /// - protected bool IsHost { get; private set; } + public bool IsHost { get; private set; } /// /// Gets Whether or not the object has a owner @@ -570,11 +570,11 @@ private static FieldInfo[] GetFieldInfoForTypeRecursive(Type type, List(); - list.AddRange(type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)); + list.AddRange(type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); } else { - list.AddRange(type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance)); + list.AddRange(type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); } if (type.BaseType != null && type.BaseType != typeof(NetworkBehaviour)) diff --git a/Runtime/Core/NetworkBehaviourUpdater.cs b/Runtime/Core/NetworkBehaviourUpdater.cs index e20fe90..2ebb281 100644 --- a/Runtime/Core/NetworkBehaviourUpdater.cs +++ b/Runtime/Core/NetworkBehaviourUpdater.cs @@ -72,6 +72,23 @@ internal void NetworkBehaviourUpdate(NetworkManager networkManager) } } } + + foreach (var dirtyObj in m_DirtyNetworkObjects) + { + for (int k = 0; k < dirtyObj.ChildNetworkBehaviours.Count; k++) + { + var behaviour = dirtyObj.ChildNetworkBehaviours[k]; + for (int i = 0; i < behaviour.NetworkVariableFields.Count; i++) + { + if (behaviour.NetworkVariableFields[i].IsDirty() && + !behaviour.NetworkVariableIndexesToResetSet.Contains(i)) + { + behaviour.NetworkVariableIndexesToResetSet.Add(i); + behaviour.NetworkVariableIndexesToReset.Add(i); + } + } + } + } // Now, reset all the no-longer-dirty variables foreach (var dirtyobj in m_DirtyNetworkObjects) { diff --git a/Runtime/Core/NetworkManager.cs b/Runtime/Core/NetworkManager.cs index a88d353..4cc8ba7 100644 --- a/Runtime/Core/NetworkManager.cs +++ b/Runtime/Core/NetworkManager.cs @@ -67,6 +67,9 @@ internal void MarkNetworkObjectDirty(NetworkObject networkObject) internal Dictionary ClientsToApprove = new Dictionary(); + // Stores the objects that need to be shown at end-of-frame + internal Dictionary> ObjectsToShowToClient = new Dictionary>(); + /// /// The instance created after starting the /// @@ -140,15 +143,55 @@ public bool OnVerifyCanSend(ulong destinationId, Type messageType, NetworkDelive public bool OnVerifyCanReceive(ulong senderId, Type messageType, FastBufferReader messageContent, ref NetworkContext context) { - if (m_NetworkManager.PendingClients.TryGetValue(senderId, out PendingClient client) && - (client.ConnectionState == PendingClient.State.PendingApproval || (client.ConnectionState == PendingClient.State.PendingConnection && messageType != typeof(ConnectionRequestMessage)))) + if (m_NetworkManager.IsServer) { - if (NetworkLog.CurrentLogLevel <= LogLevel.Normal) + if (messageType == typeof(ConnectionApprovedMessage)) + { + 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: {MessagingSystem.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}"); + } + return false; + } + if (m_NetworkManager.PendingClients.TryGetValue(senderId, out PendingClient client) && + (client.ConnectionState == PendingClient.State.PendingApproval || (client.ConnectionState == PendingClient.State.PendingConnection && messageType != typeof(ConnectionRequestMessage)))) { - NetworkLog.LogWarning($"Message received from {nameof(senderId)}={senderId} before it has been accepted"); + if (NetworkLog.CurrentLogLevel <= LogLevel.Normal) + { + NetworkLog.LogWarning($"Message received from {nameof(senderId)}={senderId} before it has been accepted"); + } + + return false; } - return false; + if (m_NetworkManager.ConnectedClients.TryGetValue(senderId, out NetworkClient connectedClient) && messageType == typeof(ConnectionRequestMessage)) + { + 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: {MessagingSystem.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}"); + } + + return false; + } + } + else + { + if (messageType == typeof(ConnectionRequestMessage)) + { + 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: {MessagingSystem.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}"); + } + return false; + } + if (m_NetworkManager.IsConnectedClient && messageType == typeof(ConnectionApprovedMessage)) + { + 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: {MessagingSystem.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}"); + } + return false; + } } return !m_NetworkManager.m_StopProcessingMessages; @@ -195,14 +238,14 @@ public GameObject GetNetworkPrefabOverride(GameObject gameObject) { if (gameObject.TryGetComponent(out var networkObject)) { - if (NetworkConfig.NetworkPrefabOverrideLinks.ContainsKey(networkObject.GlobalObjectIdHash)) + if (NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.ContainsKey(networkObject.GlobalObjectIdHash)) { - switch (NetworkConfig.NetworkPrefabOverrideLinks[networkObject.GlobalObjectIdHash].Override) + switch (NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[networkObject.GlobalObjectIdHash].Override) { case NetworkPrefabOverride.Hash: case NetworkPrefabOverride.Prefab: { - return NetworkConfig.NetworkPrefabOverrideLinks[networkObject.GlobalObjectIdHash].OverridingTargetPrefab; + return NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[networkObject.GlobalObjectIdHash].OverridingTargetPrefab; } } } @@ -280,7 +323,7 @@ public GameObject GetNetworkPrefabOverride(GameObject gameObject) /// public ulong LocalClientId { - get => IsServer ? NetworkConfig.NetworkTransport.ServerClientId : m_LocalClientId; + get => m_LocalClientId; internal set => m_LocalClientId = value; } @@ -508,6 +551,19 @@ public Action ConnectionA internal static event Action OnSingletonReady; +#if UNITY_EDITOR + internal delegate void ResetNetworkManagerDelegate(NetworkManager manager); + + internal static ResetNetworkManagerDelegate OnNetworkManagerReset; +#endif + + private void Reset() + { +#if UNITY_EDITOR + OnNetworkManagerReset?.Invoke(this); +#endif + } + #if UNITY_EDITOR internal void OnValidate() { @@ -533,72 +589,38 @@ internal void OnValidate() } // During OnValidate we will always clear out NetworkPrefabOverrideLinks and rebuild it - NetworkConfig.NetworkPrefabOverrideLinks.Clear(); + NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.Clear(); + var prefabs = NetworkConfig.Prefabs.Prefabs; // Check network prefabs and assign to dictionary for quick look up - for (int i = 0; i < NetworkConfig.NetworkPrefabs.Count; i++) + for (int i = 0; i < prefabs.Count; i++) { - var networkPrefab = NetworkConfig.NetworkPrefabs[i]; + var networkPrefab = prefabs[i]; var networkPrefabGo = networkPrefab?.Prefab; - if (networkPrefabGo != null) + if (networkPrefabGo == null) + { + continue; + } + + var networkObject = networkPrefabGo.GetComponent(); + if (networkObject == null) { - if (!networkPrefabGo.TryGetComponent(out var networkObject)) + if (NetworkLog.CurrentLogLevel <= LogLevel.Normal) { - if (NetworkLog.CurrentLogLevel <= LogLevel.Normal) - { - NetworkLog.LogError($"Cannot register {PrefabDebugHelper(networkPrefab)}, it does not have a {nameof(NetworkObject)} component at its root"); - } + NetworkLog.LogError($"Cannot register {PrefabDebugHelper(networkPrefab)}, it does not have a {nameof(NetworkObject)} component at its root"); } - else - { - { - var childNetworkObjects = new List(); - networkPrefabGo.GetComponentsInChildren(true, childNetworkObjects); - if (childNetworkObjects.Count > 1) // total count = 1 root NetworkObject + n child NetworkObjects - { - if (NetworkLog.CurrentLogLevel <= LogLevel.Normal) - { - NetworkLog.LogWarning($"{PrefabDebugHelper(networkPrefab)} has child {nameof(NetworkObject)}(s) but they will not be spawned across the network (unsupported {nameof(NetworkPrefab)} setup)"); - } - } - } - - // Default to the standard NetworkPrefab.Prefab's NetworkObject first - var globalObjectIdHash = networkObject.GlobalObjectIdHash; - - // Now check to see if it has an override - switch (networkPrefab.Override) - { - case NetworkPrefabOverride.Prefab: - { - if (NetworkConfig.NetworkPrefabs[i].SourcePrefabToOverride == null && - NetworkConfig.NetworkPrefabs[i].Prefab != null) - { - if (networkPrefab.SourcePrefabToOverride == null) - { - networkPrefab.SourcePrefabToOverride = networkPrefabGo; - } - globalObjectIdHash = networkPrefab.SourcePrefabToOverride.GetComponent().GlobalObjectIdHash; - } - - break; - } - case NetworkPrefabOverride.Hash: - globalObjectIdHash = networkPrefab.SourceHashToOverride; - break; - } + continue; + } - // Add to the NetworkPrefabOverrideLinks or handle a new (blank) entries - if (!NetworkConfig.NetworkPrefabOverrideLinks.ContainsKey(globalObjectIdHash)) - { - NetworkConfig.NetworkPrefabOverrideLinks.Add(globalObjectIdHash, networkPrefab); - } - else + { + var childNetworkObjects = new List(); + networkPrefabGo.GetComponentsInChildren(true, childNetworkObjects); + if (childNetworkObjects.Count > 1) // total count = 1 root NetworkObject + n child NetworkObjects + { + if (NetworkLog.CurrentLogLevel <= LogLevel.Normal) { - // Duplicate entries can happen when adding a new entry into a list of existing entries - // Either this is user error or a new entry, either case we replace it with a new, blank, NetworkPrefab under this condition - NetworkConfig.NetworkPrefabs[i] = new NetworkPrefab(); + NetworkLog.LogWarning($"{PrefabDebugHelper(networkPrefab)} has child {nameof(NetworkObject)}(s) but they will not be spawned across the network (unsupported {nameof(NetworkPrefab)} setup)"); } } } @@ -640,22 +662,9 @@ public void AddNetworkPrefab(GameObject prefab) } var networkPrefab = new NetworkPrefab { Prefab = prefab }; - NetworkConfig.NetworkPrefabs.Add(networkPrefab); - if (IsListening) + bool added = NetworkConfig.Prefabs.Add(networkPrefab); + if (IsListening && added) { - var sourcePrefabGlobalObjectIdHash = (uint)0; - var targetPrefabGlobalObjectIdHash = (uint)0; - if (!ShouldAddPrefab(networkPrefab, out sourcePrefabGlobalObjectIdHash, out targetPrefabGlobalObjectIdHash)) - { - NetworkConfig.NetworkPrefabs.Remove(networkPrefab); - return; - } - - if (!AddPrefabRegistration(networkPrefab, sourcePrefabGlobalObjectIdHash, targetPrefabGlobalObjectIdHash)) - { - NetworkConfig.NetworkPrefabs.Remove(networkPrefab); - return; - } DeferredMessageManager.ProcessTriggers(IDeferredMessageManager.TriggerType.OnAddPrefab, networkObject.GlobalObjectIdHash); } } @@ -678,221 +687,14 @@ public void RemoveNetworkPrefab(GameObject prefab) } var globalObjectIdHash = prefab.GetComponent().GlobalObjectIdHash; - for (var i = 0; i < NetworkConfig.NetworkPrefabs.Count; ++i) - { - if (NetworkConfig.NetworkPrefabs[i].Prefab.GetComponent().GlobalObjectIdHash == globalObjectIdHash) - { - NetworkConfig.NetworkPrefabs.RemoveAt(i); - break; - } - } + NetworkConfig.Prefabs.Remove(prefab); if (PrefabHandler.ContainsHandler(globalObjectIdHash)) { PrefabHandler.RemoveHandler(globalObjectIdHash); } - if (NetworkConfig.NetworkPrefabOverrideLinks.TryGetValue(globalObjectIdHash, out var targetPrefab)) - { - NetworkConfig.NetworkPrefabOverrideLinks.Remove(globalObjectIdHash); - var targetHash = targetPrefab.Prefab.GetComponent().GlobalObjectIdHash; - if (NetworkConfig.OverrideToNetworkPrefab.ContainsKey(targetHash)) - { - NetworkConfig.OverrideToNetworkPrefab.Remove(targetHash); - } - } - } - - private bool ShouldAddPrefab(NetworkPrefab networkPrefab, out uint sourcePrefabGlobalObjectIdHash, out uint targetPrefabGlobalObjectIdHash, int index = -1) - { - sourcePrefabGlobalObjectIdHash = 0; - targetPrefabGlobalObjectIdHash = 0; - var networkObject = (NetworkObject)null; - if (networkPrefab == null || (networkPrefab.Prefab == null && networkPrefab.Override == NetworkPrefabOverride.None)) - { - if (NetworkLog.CurrentLogLevel <= LogLevel.Error) - { - NetworkLog.LogWarning( - $"{nameof(NetworkPrefab)} cannot be null ({nameof(NetworkPrefab)} at index: {index})"); - } - return false; - } - else if (networkPrefab.Override == NetworkPrefabOverride.None) - { - if (!networkPrefab.Prefab.TryGetComponent(out networkObject)) - { - if (NetworkLog.CurrentLogLevel <= LogLevel.Error) - { - NetworkLog.LogWarning($"{PrefabDebugHelper(networkPrefab)} is missing " + - $"a {nameof(NetworkObject)} component (entry will be ignored)."); - } - return false; - } - - // Otherwise get the GlobalObjectIdHash value - sourcePrefabGlobalObjectIdHash = networkObject.GlobalObjectIdHash; - } - else // Validate Overrides - { - // Validate source prefab override values first - switch (networkPrefab.Override) - { - case NetworkPrefabOverride.Hash: - { - if (networkPrefab.SourceHashToOverride == 0) - { - if (NetworkLog.CurrentLogLevel <= LogLevel.Error) - { - NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(NetworkPrefab.SourceHashToOverride)} is zero " + - "(entry will be ignored)."); - } - return false; - } - sourcePrefabGlobalObjectIdHash = networkPrefab.SourceHashToOverride; - break; - } - case NetworkPrefabOverride.Prefab: - { - if (networkPrefab.SourcePrefabToOverride == null) - { - if (NetworkLog.CurrentLogLevel <= LogLevel.Error) - { - NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(NetworkPrefab.SourcePrefabToOverride)} is null (entry will be ignored)."); - } - - Debug.LogWarning($"{nameof(NetworkPrefab)} override entry {networkPrefab.SourceHashToOverride} will be removed and ignored."); - return false; - } - else - { - if (!networkPrefab.SourcePrefabToOverride.TryGetComponent(out networkObject)) - { - if (NetworkLog.CurrentLogLevel <= LogLevel.Error) - { - NetworkLog.LogWarning($"{nameof(NetworkPrefab)} ({networkPrefab.SourcePrefabToOverride.name}) " + - $"is missing a {nameof(NetworkObject)} component (entry will be ignored)."); - } - - Debug.LogWarning($"{nameof(NetworkPrefab)} override entry (\"{networkPrefab.SourcePrefabToOverride.name}\") will be removed and ignored."); - return false; - } - - sourcePrefabGlobalObjectIdHash = networkObject.GlobalObjectIdHash; - } - break; - } - } - - // Validate target prefab override values next - if (networkPrefab.OverridingTargetPrefab == null) - { - if (NetworkLog.CurrentLogLevel <= LogLevel.Error) - { - NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(NetworkPrefab.OverridingTargetPrefab)} is null!"); - } - switch (networkPrefab.Override) - { - case NetworkPrefabOverride.Hash: - { - Debug.LogWarning($"{nameof(NetworkPrefab)} override entry {networkPrefab.SourceHashToOverride} will be removed and ignored."); - break; - } - case NetworkPrefabOverride.Prefab: - { - Debug.LogWarning($"{nameof(NetworkPrefab)} override entry ({networkPrefab.SourcePrefabToOverride.name}) will be removed and ignored."); - break; - } - } - return false; - } - else - { - targetPrefabGlobalObjectIdHash = networkPrefab.OverridingTargetPrefab.GetComponent().GlobalObjectIdHash; - } - } - return true; - } - - internal bool AddPrefabRegistration(NetworkPrefab networkPrefab, uint sourcePrefabGlobalObjectIdHash, uint targetPrefabGlobalObjectIdHash) - { - // Assign the appropriate GlobalObjectIdHash to the appropriate NetworkPrefab - if (!NetworkConfig.NetworkPrefabOverrideLinks.ContainsKey(sourcePrefabGlobalObjectIdHash)) - { - if (networkPrefab.Override == NetworkPrefabOverride.None) - { - NetworkConfig.NetworkPrefabOverrideLinks.Add(sourcePrefabGlobalObjectIdHash, networkPrefab); - } - else - { - if (!NetworkConfig.OverrideToNetworkPrefab.ContainsKey(targetPrefabGlobalObjectIdHash)) - { - switch (networkPrefab.Override) - { - case NetworkPrefabOverride.Prefab: - { - NetworkConfig.NetworkPrefabOverrideLinks.Add(sourcePrefabGlobalObjectIdHash, networkPrefab); - NetworkConfig.OverrideToNetworkPrefab.Add(targetPrefabGlobalObjectIdHash, sourcePrefabGlobalObjectIdHash); - } - break; - case NetworkPrefabOverride.Hash: - { - NetworkConfig.NetworkPrefabOverrideLinks.Add(sourcePrefabGlobalObjectIdHash, networkPrefab); - NetworkConfig.OverrideToNetworkPrefab.Add(targetPrefabGlobalObjectIdHash, sourcePrefabGlobalObjectIdHash); - } - break; - } - } - else - { - var networkObject = networkPrefab.Prefab.GetComponent(); - // 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: {targetPrefabGlobalObjectIdHash}! Removing entry from list!"); - return false; - } - } - } - else - { - var networkObject = networkPrefab.Prefab.GetComponent(); - // This should never happen, but in the case it somehow does log an error and remove the duplicate entry - Debug.LogError($"{nameof(NetworkPrefab)} ({networkObject.name}) has a duplicate {nameof(NetworkObject.GlobalObjectIdHash)} source entry value of: {sourcePrefabGlobalObjectIdHash}! Removing entry from list!"); - return false; - } - return true; - } - - private void InitializePrefabs(int startIdx = 0) - { - // This is used to remove entries not needed or invalid - var removeEmptyPrefabs = new List(); - - // Build the NetworkPrefabOverrideLinks dictionary - for (int i = startIdx; i < NetworkConfig.NetworkPrefabs.Count; i++) - { - var sourcePrefabGlobalObjectIdHash = (uint)0; - var targetPrefabGlobalObjectIdHash = (uint)0; - if (!ShouldAddPrefab(NetworkConfig.NetworkPrefabs[i], out sourcePrefabGlobalObjectIdHash, out targetPrefabGlobalObjectIdHash, i)) - { - removeEmptyPrefabs.Add(i); - continue; - } - - if (!AddPrefabRegistration(NetworkConfig.NetworkPrefabs[i], sourcePrefabGlobalObjectIdHash, targetPrefabGlobalObjectIdHash)) - { - removeEmptyPrefabs.Add(i); - continue; - } - } - - // Clear out anything that is invalid or not used (for invalid entries we already logged warnings to the user earlier) - // Iterate backwards so indices don't shift as we remove - for (int i = removeEmptyPrefabs.Count - 1; i >= 0; i--) - { - NetworkConfig.NetworkPrefabs.RemoveAt(removeEmptyPrefabs[i]); - } - - removeEmptyPrefabs.Clear(); } - private void Initialize(bool server) + internal void Initialize(bool server) { // Don't allow the user to start a network session if the NetworkManager is // still parented under another GameObject @@ -982,11 +784,7 @@ private void Initialize(bool server) this.RegisterNetworkUpdate(NetworkUpdateStage.PreUpdate); - // Always clear our prefab override links before building - NetworkConfig.NetworkPrefabOverrideLinks.Clear(); - NetworkConfig.OverrideToNetworkPrefab.Clear(); - - InitializePrefabs(); + NetworkConfig.InitializePrefabs(); // If we have a player prefab, then we need to verify it is in the list of NetworkPrefabOverrideLinks for client side spawning. if (NetworkConfig.PlayerPrefab != null) @@ -994,15 +792,11 @@ private void Initialize(bool server) if (NetworkConfig.PlayerPrefab.TryGetComponent(out var playerPrefabNetworkObject)) { //In the event there is no NetworkPrefab entry (i.e. no override for default player prefab) - if (!NetworkConfig.NetworkPrefabOverrideLinks.ContainsKey(playerPrefabNetworkObject + if (!NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.ContainsKey(playerPrefabNetworkObject .GlobalObjectIdHash)) { //Then add a new entry for the player prefab - var playerNetworkPrefab = new NetworkPrefab(); - playerNetworkPrefab.Prefab = NetworkConfig.PlayerPrefab; - NetworkConfig.NetworkPrefabs.Insert(0, playerNetworkPrefab); - NetworkConfig.NetworkPrefabOverrideLinks.Add(playerPrefabNetworkObject.GlobalObjectIdHash, - playerNetworkPrefab); + AddNetworkPrefab(NetworkConfig.PlayerPrefab); } } else @@ -1048,6 +842,7 @@ public bool StartServer() IsServer = true; IsClient = false; IsListening = true; + LocalClientId = ServerClientId; try { @@ -1282,6 +1077,8 @@ private void OnEnable() private void Awake() { + NetworkConfig?.InitializePrefabs(); + UnityEngine.SceneManagement.SceneManager.sceneUnloaded += OnSceneUnloaded; } @@ -1663,6 +1460,17 @@ private void OnNetworkManagerTick() // Do NetworkVariable updates BehaviourUpdater.NetworkBehaviourUpdate(this); + // Handle NetworkObjects to show + foreach (var client in ObjectsToShowToClient) + { + ulong clientId = client.Key; + foreach (var networkObject in client.Value) + { + SpawnManager.SendSpawnCallForObject(clientId, networkObject); + } + } + ObjectsToShowToClient.Clear(); + int timeSyncFrequencyTicks = (int)(k_TimeSyncFrequency * NetworkConfig.TickRate); if (IsServer && NetworkTickSystem.ServerTime.Tick % timeSyncFrequencyTicks == 0) { @@ -2082,7 +1890,12 @@ private void OnClientDisconnectFromServer(ulong clientId) } else { - Destroy(playerObject.gameObject); + // Call despawn to assure NetworkBehaviour.OnNetworkDespawn is invoked + // on the server-side (when the client side disconnected). + // This prevents the issue (when just destroying the GameObject) where + // any NetworkBehaviour component(s) destroyed before the NetworkObject + // would not have OnNetworkDespawn invoked. + SpawnManager.DespawnObject(playerObject, true); } } else @@ -2334,5 +2147,37 @@ internal void ApprovedPlayerSpawn(ulong clientId, uint playerPrefabHash) NetworkMetrics.TrackObjectSpawnSent(clientPair.Key, ConnectedClients[clientId].PlayerObject, size); } } + + internal void MarkObjectForShowingTo(NetworkObject networkObject, ulong clientId) + { + if (!ObjectsToShowToClient.ContainsKey(clientId)) + { + ObjectsToShowToClient.Add(clientId, new List()); + } + ObjectsToShowToClient[clientId].Add(networkObject); + } + + // returns whether any matching objects would have become visible and were returned to hidden state + internal bool RemoveObjectFromShowingTo(NetworkObject networkObject, ulong clientId) + { + var ret = false; + if (!ObjectsToShowToClient.ContainsKey(clientId)) + { + return false; + } + + // probably overkill, but deals with multiple entries + while (ObjectsToShowToClient[clientId].Contains(networkObject)) + { + Debug.LogWarning( + "Object was shown and hidden from the same client in the same Network frame. As a result, the client will _not_ receive a NetworkSpawn"); + ObjectsToShowToClient[clientId].Remove(networkObject); + ret = true; + } + + networkObject.Observers.Remove(clientId); + + return ret; + } } } diff --git a/Runtime/Core/NetworkObject.cs b/Runtime/Core/NetworkObject.cs index 122b6f1..1e52e52 100644 --- a/Runtime/Core/NetworkObject.cs +++ b/Runtime/Core/NetworkObject.cs @@ -265,9 +265,8 @@ public void NetworkShow(ulong clientId) throw new VisibilityChangeException("The object is already visible"); } + NetworkManager.MarkObjectForShowingTo(this, clientId); Observers.Add(clientId); - - NetworkManager.SpawnManager.SendSpawnCallForObject(clientId, this); } @@ -351,26 +350,28 @@ public void NetworkHide(ulong clientId) throw new NotServerException("Only server can change visibility"); } - if (!Observers.Contains(clientId)) - { - throw new VisibilityChangeException("The object is already hidden"); - } - if (clientId == NetworkManager.ServerClientId) { throw new VisibilityChangeException("Cannot hide an object from the server"); } - Observers.Remove(clientId); - - var message = new DestroyObjectMessage + if (!NetworkManager.RemoveObjectFromShowingTo(this, clientId)) { - NetworkObjectId = NetworkObjectId, - DestroyGameObject = !IsSceneObject.Value - }; - // Send destroy call - var size = NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientId); - NetworkManager.NetworkMetrics.TrackObjectDestroySent(clientId, this, size); + if (!Observers.Contains(clientId)) + { + throw new VisibilityChangeException("The object is already hidden"); + } + Observers.Remove(clientId); + + var message = new DestroyObjectMessage + { + NetworkObjectId = NetworkObjectId, + DestroyGameObject = !IsSceneObject.Value + }; + // Send destroy call + var size = NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientId); + NetworkManager.NetworkMetrics.TrackObjectDestroySent(clientId, this, size); + } } /// @@ -1454,9 +1455,9 @@ internal uint HostCheckForGlobalObjectIdHashOverride() var globalObjectIdHash = NetworkManager.PrefabHandler.GetSourceGlobalObjectIdHash(GlobalObjectIdHash); return globalObjectIdHash == 0 ? GlobalObjectIdHash : globalObjectIdHash; } - else if (NetworkManager.NetworkConfig.OverrideToNetworkPrefab.ContainsKey(GlobalObjectIdHash)) + if (NetworkManager.NetworkConfig.Prefabs.OverrideToNetworkPrefab.TryGetValue(GlobalObjectIdHash, out uint hash)) { - return NetworkManager.NetworkConfig.OverrideToNetworkPrefab[GlobalObjectIdHash]; + return hash; } } diff --git a/Runtime/Messaging/BatchHeader.cs b/Runtime/Messaging/BatchHeader.cs index a7302f5..63b79fe 100644 --- a/Runtime/Messaging/BatchHeader.cs +++ b/Runtime/Messaging/BatchHeader.cs @@ -5,9 +5,26 @@ namespace Unity.Netcode /// internal struct BatchHeader : INetworkSerializeByMemcpy { + internal const ushort MagicValue = 0x1160; + /// + /// A magic number to detect corrupt messages. + /// Always set to k_MagicValue + /// + public ushort Magic; + + /// + /// Total number of bytes in the batch. + /// + public int BatchSize; + + /// + /// Hash of the message to detect corrupt messages. + /// + public ulong BatchHash; + /// /// Total number of messages in the batch. /// - public ushort BatchSize; + public ushort BatchCount; } } diff --git a/Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs b/Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs index ba3289a..78b2983 100644 --- a/Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs +++ b/Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs @@ -64,6 +64,16 @@ public void Serialize(FastBufferWriter writer, int targetVersion) shouldWrite = false; } + // 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.ObjectsToShowToClient.ContainsKey(TargetClientId) && + NetworkBehaviour.NetworkManager.ObjectsToShowToClient[TargetClientId] + .Contains(NetworkBehaviour.NetworkObject)) + { + shouldWrite = false; + } + if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety) { if (!shouldWrite) @@ -96,12 +106,6 @@ public void Serialize(FastBufferWriter writer, int targetVersion) networkVariable.WriteDelta(writer); } - if (!NetworkBehaviour.NetworkVariableIndexesToResetSet.Contains(i)) - { - NetworkBehaviour.NetworkVariableIndexesToResetSet.Add(i); - NetworkBehaviour.NetworkVariableIndexesToReset.Add(i); - } - NetworkBehaviour.NetworkManager.NetworkMetrics.TrackNetworkVariableDeltaSent( TargetClientId, NetworkBehaviour.NetworkObject, diff --git a/Runtime/Messaging/MessagingSystem.cs b/Runtime/Messaging/MessagingSystem.cs index 6f5fca5..b384d3b 100644 --- a/Runtime/Messaging/MessagingSystem.cs +++ b/Runtime/Messaging/MessagingSystem.cs @@ -2,6 +2,7 @@ using System.Collections; using System.Collections.Generic; using System.Runtime.CompilerServices; +using System.Text; using Unity.Collections; using Unity.Collections.LowLevel.Unsafe; using UnityEngine; @@ -41,7 +42,7 @@ public SendQueueItem(NetworkDelivery delivery, int writerSize, Allocator writerA { Writer = new FastBufferWriter(writerSize, writerAllocator, maxWriterSize); NetworkDelivery = delivery; - BatchHeader = default; + BatchHeader = new BatchHeader { Magic = BatchHeader.MagicValue }; } } @@ -204,6 +205,17 @@ public int GetLocalVersion(Type messageType) return m_LocalVersions[messageType]; } + internal static string ByteArrayToString(byte[] ba, int offset, int count) + { + var hex = new StringBuilder(ba.Length * 2); + for (int i = offset; i < offset + count; ++i) + { + hex.AppendFormat("{0:x2} ", ba[i]); + } + + return hex.ToString(); + } + internal void HandleIncomingData(ulong clientId, ArraySegment data, float receiveTime) { unsafe @@ -214,18 +226,38 @@ internal void HandleIncomingData(ulong clientId, ArraySegment data, float new FastBufferReader(nativeData + data.Offset, Allocator.None, data.Count); if (!batchReader.TryBeginRead(sizeof(BatchHeader))) { - NetworkLog.LogWarning("Received a packet too small to contain a BatchHeader. Ignoring it."); + NetworkLog.LogError("Received a packet too small to contain a BatchHeader. Ignoring it."); return; } batchReader.ReadValue(out BatchHeader batchHeader); + if (batchHeader.Magic != BatchHeader.MagicValue) + { + NetworkLog.LogError($"Received a packet with an invalid Magic Value. 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: Offset: {data.Offset}, Size: {data.Count}, Full receive array: {ByteArrayToString(data.Array, 0, data.Array.Length)}"); + return; + } + + if (batchHeader.BatchSize != data.Count) + { + NetworkLog.LogError($"Received a packet with an invalid Batch Size Value. 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: Offset: {data.Offset}, Size: {data.Count}, Expected Size: {batchHeader.BatchSize}, Full receive array: {ByteArrayToString(data.Array, 0, data.Array.Length)}"); + return; + } + + var hash = XXHash.Hash64(batchReader.GetUnsafePtrAtCurrentPosition(), batchReader.Length - batchReader.Position); + + if (hash != batchHeader.BatchHash) + { + NetworkLog.LogError($"Received a packet with an invalid Hash Value. 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: Received Hash: {batchHeader.BatchHash}, Calculated Hash: {hash}, Offset: {data.Offset}, Size: {data.Count}, Full receive array: {ByteArrayToString(data.Array, 0, data.Array.Length)}"); + return; + } + for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx) { - m_Hooks[hookIdx].OnBeforeReceiveBatch(clientId, batchHeader.BatchSize, batchReader.Length); + m_Hooks[hookIdx].OnBeforeReceiveBatch(clientId, batchHeader.BatchCount, batchReader.Length); } - for (var messageIdx = 0; messageIdx < batchHeader.BatchSize; ++messageIdx) + for (var messageIdx = 0; messageIdx < batchHeader.BatchCount; ++messageIdx) { var messageHeader = new MessageHeader(); @@ -237,7 +269,7 @@ internal void HandleIncomingData(ulong clientId, ArraySegment data, float } catch (OverflowException) { - NetworkLog.LogWarning("Received a batch that didn't have enough data for all of its batches, ending early!"); + NetworkLog.LogError("Received a batch that didn't have enough data for all of its batches, ending early!"); throw; } @@ -245,7 +277,7 @@ internal void HandleIncomingData(ulong clientId, ArraySegment data, float if (!batchReader.TryBeginRead((int)messageHeader.MessageSize)) { - NetworkLog.LogWarning("Received a message that claimed a size larger than the packet, ending early!"); + NetworkLog.LogError("Received a message that claimed a size larger than the packet, ending early!"); return; } m_IncomingMessageQueue.Add(new ReceiveQueueItem @@ -263,7 +295,7 @@ internal void HandleIncomingData(ulong clientId, ArraySegment data, float } for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx) { - m_Hooks[hookIdx].OnAfterReceiveBatch(clientId, batchHeader.BatchSize, batchReader.Length); + m_Hooks[hookIdx].OnAfterReceiveBatch(clientId, batchHeader.BatchCount, batchReader.Length); } } } @@ -650,7 +682,7 @@ internal unsafe int SendPreSerializedMessage(in FastBufferWriter t writeQueueItem.Writer.WriteBytes(headerSerializer.GetUnsafePtr(), headerSerializer.Length); writeQueueItem.Writer.WriteBytes(tmpSerializer.GetUnsafePtr(), tmpSerializer.Length); - writeQueueItem.BatchHeader.BatchSize++; + writeQueueItem.BatchHeader.BatchCount++; for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx) { m_Hooks[hookIdx].OnAfterSendMessage(clientId, ref message, delivery, tmpSerializer.Length + headerSerializer.Length); @@ -745,7 +777,7 @@ internal unsafe void ProcessSendQueues() for (var i = 0; i < sendQueueItem.Length; ++i) { ref var queueItem = ref sendQueueItem.ElementAt(i); - if (queueItem.BatchHeader.BatchSize == 0) + if (queueItem.BatchHeader.BatchCount == 0) { queueItem.Writer.Dispose(); continue; @@ -753,23 +785,28 @@ internal unsafe void ProcessSendQueues() for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx) { - m_Hooks[hookIdx].OnBeforeSendBatch(clientId, queueItem.BatchHeader.BatchSize, queueItem.Writer.Length, queueItem.NetworkDelivery); + m_Hooks[hookIdx].OnBeforeSendBatch(clientId, queueItem.BatchHeader.BatchCount, queueItem.Writer.Length, queueItem.NetworkDelivery); } queueItem.Writer.Seek(0); #if UNITY_EDITOR || DEVELOPMENT_BUILD // Skipping the Verify and sneaking the write mark in because we know it's fine. - queueItem.Writer.Handle->AllowedWriteMark = 2; + queueItem.Writer.Handle->AllowedWriteMark = sizeof(BatchHeader); #endif + queueItem.BatchHeader.BatchHash = XXHash.Hash64(queueItem.Writer.GetUnsafePtr() + sizeof(BatchHeader), queueItem.Writer.Length - sizeof(BatchHeader)); + + queueItem.BatchHeader.BatchSize = queueItem.Writer.Length; + queueItem.Writer.WriteValue(queueItem.BatchHeader); + try { m_MessageSender.Send(clientId, queueItem.NetworkDelivery, queueItem.Writer); for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx) { - m_Hooks[hookIdx].OnAfterSendBatch(clientId, queueItem.BatchHeader.BatchSize, queueItem.Writer.Length, queueItem.NetworkDelivery); + m_Hooks[hookIdx].OnAfterSendBatch(clientId, queueItem.BatchHeader.BatchCount, queueItem.Writer.Length, queueItem.NetworkDelivery); } } finally diff --git a/Runtime/NetworkVariable/NetworkVariableBase.cs b/Runtime/NetworkVariable/NetworkVariableBase.cs index d3e4c0e..7addee2 100644 --- a/Runtime/NetworkVariable/NetworkVariableBase.cs +++ b/Runtime/NetworkVariable/NetworkVariableBase.cs @@ -18,6 +18,11 @@ public abstract class NetworkVariableBase : IDisposable /// private protected NetworkBehaviour m_NetworkBehaviour; + public NetworkBehaviour GetBehaviour() + { + return m_NetworkBehaviour; + } + /// /// Initializes the NetworkVariable /// diff --git a/Runtime/SceneManagement/NetworkSceneManager.cs b/Runtime/SceneManagement/NetworkSceneManager.cs index 781326f..b538903 100644 --- a/Runtime/SceneManagement/NetworkSceneManager.cs +++ b/Runtime/SceneManagement/NetworkSceneManager.cs @@ -862,16 +862,6 @@ private SceneEventProgress ValidateSceneEvent(string sceneName, bool isUnloading SceneEventProgressTracking.Add(sceneEventProgress.Guid, sceneEventProgress); - if (!isUnloading) - { - // The Condition: While a scene is asynchronously loaded in single loading scene mode, if any new NetworkObjects are spawned - // they need to be moved into the do not destroy temporary scene - // When it is set: Just before starting the asynchronous loading call - // When it is unset: After the scene has loaded, the PopulateScenePlacedObjects is called, and all NetworkObjects in the do - // not destroy temporary scene are moved into the active scene - IsSpawnedObjectsPendingInDontDestroyOnLoad = true; - } - m_IsSceneEventActive = true; // Set our callback delegate handler for completion @@ -1162,6 +1152,13 @@ public SceneEventProgressStatus LoadScene(string sceneName, LoadSceneMode loadSc if (sceneEventData.LoadSceneMode == LoadSceneMode.Single) { + // The Condition: While a scene is asynchronously loaded in single loading scene mode, if any new NetworkObjects are spawned + // they need to be moved into the do not destroy temporary scene + // When it is set: Just before starting the asynchronous loading call + // When it is unset: After the scene has loaded, the PopulateScenePlacedObjects is called, and all NetworkObjects in the do + // not destroy temporary scene are moved into the active scene + IsSpawnedObjectsPendingInDontDestroyOnLoad = true; + // Destroy current scene objects before switching. m_NetworkManager.SpawnManager.ServerDestroySpawnedSceneObjects(); diff --git a/Runtime/Serialization/BufferSerializer.cs b/Runtime/Serialization/BufferSerializer.cs index 4f35888..4afd457 100644 --- a/Runtime/Serialization/BufferSerializer.cs +++ b/Runtime/Serialization/BufferSerializer.cs @@ -7,14 +7,10 @@ namespace Unity.Netcode /// /// Two-way serializer wrapping FastBufferReader or FastBufferWriter. /// - /// Implemented as a ref struct for two reasons: - /// 1. The BufferSerializer cannot outlive the FBR/FBW it wraps or using it will cause a crash - /// 2. The BufferSerializer must always be passed by reference and can't be copied + /// Implemented as a ref struct to help enforce the requirement that + /// the BufferSerializer cannot outlive the FBR/FBW it wraps or using it will cause a crash /// - /// Ref structs help enforce both of those rules: they can't ref live the stack context in which they were - /// created, and they're always passed by reference no matter what. - /// - /// BufferSerializer doesn't wrapp FastBufferReader or FastBufferWriter directly because it can't. + /// BufferSerializer doesn't wrap FastBufferReader or FastBufferWriter directly because it can't. /// ref structs can't implement interfaces, and in order to be able to have two different implementations with /// the same interface (which allows us to avoid an "if(IsReader)" on every call), the thing directly wrapping /// the struct has to implement an interface. So IReaderWriter exists as the interface, diff --git a/Runtime/Spawning/NetworkSpawnManager.cs b/Runtime/Spawning/NetworkSpawnManager.cs index b354ffe..131489a 100644 --- a/Runtime/Spawning/NetworkSpawnManager.cs +++ b/Runtime/Spawning/NetworkSpawnManager.cs @@ -300,7 +300,7 @@ internal bool HasPrefab(NetworkObject.SceneObject sceneObject) { return true; } - if (NetworkManager.NetworkConfig.NetworkPrefabOverrideLinks.TryGetValue(sceneObject.Hash, out var networkPrefab)) + if (NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.TryGetValue(sceneObject.Hash, out var networkPrefab)) { switch (networkPrefab.Override) { @@ -352,17 +352,17 @@ internal NetworkObject CreateLocalNetworkObject(NetworkObject.SceneObject sceneO { // See if there is a valid registered NetworkPrefabOverrideLink associated with the provided prefabHash GameObject networkPrefabReference = null; - if (NetworkManager.NetworkConfig.NetworkPrefabOverrideLinks.ContainsKey(globalObjectIdHash)) + if (NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.ContainsKey(globalObjectIdHash)) { - switch (NetworkManager.NetworkConfig.NetworkPrefabOverrideLinks[globalObjectIdHash].Override) + switch (NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[globalObjectIdHash].Override) { default: case NetworkPrefabOverride.None: - networkPrefabReference = NetworkManager.NetworkConfig.NetworkPrefabOverrideLinks[globalObjectIdHash].Prefab; + networkPrefabReference = NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[globalObjectIdHash].Prefab; break; case NetworkPrefabOverride.Hash: case NetworkPrefabOverride.Prefab: - networkPrefabReference = NetworkManager.NetworkConfig.NetworkPrefabOverrideLinks[globalObjectIdHash].OverridingTargetPrefab; + networkPrefabReference = NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[globalObjectIdHash].OverridingTargetPrefab; break; } } @@ -603,6 +603,11 @@ private void SpawnNetworkObjectLocallyCommon(NetworkObject networkObject, ulong var children = networkObject.GetComponentsInChildren(); foreach (var childObject in children) { + // Do not propagate the in-scene object setting if a child was dynamically spawned. + if (childObject.IsSceneObject.HasValue && !childObject.IsSceneObject.Value) + { + continue; + } childObject.IsSceneObject = sceneObject; } } diff --git a/Runtime/Transports/UTP/BatchedSendQueue.cs b/Runtime/Transports/UTP/BatchedSendQueue.cs index c305884..6f81eea 100644 --- a/Runtime/Transports/UTP/BatchedSendQueue.cs +++ b/Runtime/Transports/UTP/BatchedSendQueue.cs @@ -226,7 +226,7 @@ public int FillWriterWithMessages(ref DataStreamWriter writer) { writer.WriteInt(messageLength); - var messageOffset = HeadIndex + reader.GetBytesRead(); + var messageOffset = reader.GetBytesRead(); WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + messageOffset, messageLength); writerAvailable -= sizeof(int) + messageLength; diff --git a/Runtime/Transports/UTP/UnityTransport.cs b/Runtime/Transports/UTP/UnityTransport.cs index 84eeed7..410db46 100644 --- a/Runtime/Transports/UTP/UnityTransport.cs +++ b/Runtime/Transports/UTP/UnityTransport.cs @@ -145,7 +145,7 @@ private enum State // Maximum reliable throughput, assuming the full reliable window can be sent on every // frame at 60 FPS. This will be a large over-estimation in any realistic scenario. - private const int k_MaxReliableThroughput = (NetworkParameterConstants.MTU * 32 * 60) / 1000; // bytes per millisecond + private const int k_MaxReliableThroughput = (NetworkParameterConstants.MTU * 64 * 60) / 1000; // bytes per millisecond private static ConnectionAddressData s_DefaultConnectionAddressData = new ConnectionAddressData { Address = "127.0.0.1", Port = 7777, ServerListenAddress = string.Empty }; @@ -303,20 +303,23 @@ public struct ConnectionAddressData public ushort Port; /// - /// IP address the server will listen on. If not provided, will use 'Address'. + /// IP address the server will listen on. If not provided, will use localhost. /// - [Tooltip("IP address the server will listen on. If not provided, will use 'Address'.")] + [Tooltip("IP address the server will listen on. If not provided, will use localhost.")] [SerializeField] public string ServerListenAddress; - private static NetworkEndpoint ParseNetworkEndpoint(string ip, ushort port) + private static NetworkEndpoint ParseNetworkEndpoint(string ip, ushort port, bool silent = false) { NetworkEndpoint endpoint = default; if (!NetworkEndpoint.TryParse(ip, port, out endpoint, NetworkFamily.Ipv4) && !NetworkEndpoint.TryParse(ip, port, out endpoint, NetworkFamily.Ipv6)) { - Debug.LogError($"Invalid network endpoint: {ip}:{port}."); + if (!silent) + { + Debug.LogError($"Invalid network endpoint: {ip}:{port}."); + } } return endpoint; @@ -330,9 +333,34 @@ private static NetworkEndpoint ParseNetworkEndpoint(string ip, ushort port) /// /// Endpoint (IP address and port) server will listen/bind on. /// - public NetworkEndpoint ListenEndPoint => ParseNetworkEndpoint((ServerListenAddress?.Length == 0) ? Address : ServerListenAddress, Port); + public NetworkEndpoint ListenEndPoint + { + get + { + if (string.IsNullOrEmpty(ServerListenAddress)) + { + var ep = NetworkEndpoint.LoopbackIpv4; + + // If an address was entered and it's IPv6, switch to using ::1 as the + // default listen address. (Otherwise we always assume IPv4.) + if (!string.IsNullOrEmpty(Address) && ServerEndPoint.Family == NetworkFamily.Ipv6) + { + ep = NetworkEndpoint.LoopbackIpv6; + } + + return ep.WithPort(Port); + } + else + { + return ParseNetworkEndpoint(ServerListenAddress, Port); + } + } + } + + public bool IsIpv6 => !string.IsNullOrEmpty(Address) && ParseNetworkEndpoint(Address, Port, true).Family == NetworkFamily.Ipv6; } + /// /// The connection (address) data for this instance. /// This is where you can change IP Address, Port, or server's listen address. @@ -529,14 +557,14 @@ private bool ServerBindAndListen(NetworkEndpoint endPoint) int result = m_Driver.Bind(endPoint); if (result != 0) { - Debug.LogError("Server failed to bind"); + Debug.LogError("Server failed to bind. This is usually caused by another process being bound to the same port."); return false; } result = m_Driver.Listen(); if (result != 0) { - Debug.LogError("Server failed to listen"); + Debug.LogError("Server failed to listen."); return false; } @@ -609,7 +637,7 @@ public void SetConnectionData(string ipv4Address, ushort port, string listenAddr { Address = ipv4Address, Port = port, - ServerListenAddress = listenAddress ?? string.Empty + ServerListenAddress = listenAddress ?? ipv4Address }; SetProtocol(ProtocolType.UnityTransport); @@ -1153,17 +1181,20 @@ public override void Initialize(NetworkManager networkManager = null) m_NetworkSettings = new NetworkSettings(Allocator.Persistent); -#if !UNITY_WEBGL // If the user sends a message of exactly m_MaxPayloadSize in length, we need to // account for the overhead of its length when we store it in the send queue. var fragmentationCapacity = m_MaxPayloadSize + BatchedSendQueue.PerMessageOverhead; - m_NetworkSettings.WithFragmentationStageParameters(payloadCapacity: fragmentationCapacity); -#if !UTP_TRANSPORT_2_0_ABOVE + + // Bump the reliable window size to its maximum size of 64. Since NGO makes heavy use of + // reliable delivery, we're better off with the increased window size compared to the + // extra 4 bytes of header that this costs us. + m_NetworkSettings.WithReliableStageParameters(windowSize: 64); + +#if !UTP_TRANSPORT_2_0_ABOVE && !UNITY_WEBGL m_NetworkSettings.WithBaselibNetworkInterfaceParameters( receiveQueueCapacity: m_MaxPacketQueueSize, sendQueueCapacity: m_MaxPacketQueueSize); -#endif #endif } @@ -1449,7 +1480,7 @@ public void CreateDriver(UnityTransport transport, out NetworkDriver driver, heartbeatTimeoutMS: transport.m_HeartbeatTimeoutMS); #if UNITY_WEBGL && !UNITY_EDITOR - if (NetworkManager.IsServer) + if (NetworkManager.IsServer && m_ProtocolType != ProtocolType.RelayUnityTransport) { throw new Exception("WebGL as a server is not supported by Unity Transport, outside the Editor."); } @@ -1473,7 +1504,7 @@ public void CreateDriver(UnityTransport transport, out NetworkDriver driver, { if (NetworkManager.IsServer) { - if (String.IsNullOrEmpty(m_ServerCertificate) || String.IsNullOrEmpty(m_ServerPrivateKey)) + if (string.IsNullOrEmpty(m_ServerCertificate) || string.IsNullOrEmpty(m_ServerPrivateKey)) { throw new Exception("In order to use encrypted communications, when hosting, you must set the server certificate and key."); } @@ -1482,11 +1513,11 @@ public void CreateDriver(UnityTransport transport, out NetworkDriver driver, } else { - if (String.IsNullOrEmpty(m_ServerCommonName)) + if (string.IsNullOrEmpty(m_ServerCommonName)) { throw new Exception("In order to use encrypted communications, clients must set the server common name."); } - else if (String.IsNullOrEmpty(m_ClientCaCertificate)) + else if (string.IsNullOrEmpty(m_ClientCaCertificate)) { m_NetworkSettings.WithSecureClientParameters(m_ServerCommonName); } diff --git a/TestHelpers/Runtime/AssemblyInfo.cs b/TestHelpers/Runtime/AssemblyInfo.cs index f9d973f..b21e378 100644 --- a/TestHelpers/Runtime/AssemblyInfo.cs +++ b/TestHelpers/Runtime/AssemblyInfo.cs @@ -1,6 +1,12 @@ using System.Runtime.CompilerServices; -[assembly: InternalsVisibleTo("TestProject.EditorTests")] +#if UNITY_INCLUDE_TESTS +[assembly: InternalsVisibleTo("Unity.Netcode.RuntimeTests")] [assembly: InternalsVisibleTo("TestProject.RuntimeTests")] +#if UNITY_EDITOR +[assembly: InternalsVisibleTo("TestProject.EditorTests")] +#endif // UNITY_EDITOR +#if MULTIPLAYER_TOOLS [assembly: InternalsVisibleTo("TestProject.ToolsIntegration.RuntimeTests")] -[assembly: InternalsVisibleTo("Unity.Netcode.RuntimeTests")] +#endif // MULTIPLAYER_TOOLS +#endif // UNITY_INCLUDE_TESTS diff --git a/TestHelpers/Runtime/NetcodeIntegrationTest.cs b/TestHelpers/Runtime/NetcodeIntegrationTest.cs index 9103f33..cce5d2f 100644 --- a/TestHelpers/Runtime/NetcodeIntegrationTest.cs +++ b/TestHelpers/Runtime/NetcodeIntegrationTest.cs @@ -241,11 +241,20 @@ protected virtual void OnCreatePlayerPrefab() { } + /// + /// Invoked immediately after the player prefab GameObject is created + /// prior to adding a NetworkObject component + /// + protected virtual void OnPlayerPrefabGameObjectCreated() + { + } + private void CreatePlayerPrefab() { VerboseDebug($"Entering {nameof(CreatePlayerPrefab)}"); // Create playerPrefab m_PlayerPrefab = new GameObject("Player"); + OnPlayerPrefabGameObjectCreated(); NetworkObject networkObject = m_PlayerPrefab.AddComponent(); // Make it a prefab @@ -692,6 +701,7 @@ public IEnumerator TearDown() } VerboseDebug($"Exiting {nameof(TearDown)}"); + LogWaitForMessages(); NetcodeLogAssert.Dispose(); } @@ -920,18 +930,7 @@ protected GameObject CreateNetworkObjectPrefab(string baseName) Assert.IsNotNull(m_ServerNetworkManager, prefabCreateAssertError); Assert.IsFalse(m_ServerNetworkManager.IsListening, prefabCreateAssertError); - var gameObject = new GameObject(); - gameObject.name = baseName; - var networkObject = gameObject.AddComponent(); - networkObject.NetworkManagerOwner = m_ServerNetworkManager; - NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(networkObject); - var networkPrefab = new NetworkPrefab() { Prefab = gameObject }; - m_ServerNetworkManager.NetworkConfig.NetworkPrefabs.Add(networkPrefab); - foreach (var clientNetworkManager in m_ClientNetworkManagers) - { - clientNetworkManager.NetworkConfig.NetworkPrefabs.Add(networkPrefab); - } - return gameObject; + return NetcodeIntegrationTestHelpers.CreateNetworkObjectPrefab(baseName, m_ServerNetworkManager, m_ClientNetworkManagers); } /// @@ -1059,5 +1058,61 @@ private void UnloadRemainingScenes() var asyncOperation = SceneManager.UnloadSceneAsync(scene); } } + + private System.Text.StringBuilder m_WaitForLog = new System.Text.StringBuilder(); + + private void LogWaitForMessages() + { + VerboseDebug(m_WaitForLog.ToString()); + m_WaitForLog.Clear(); + } + + private IEnumerator WaitForTickAndFrames(NetworkManager networkManager, int tickCount, float targetFrames) + { + var tickAndFramesConditionMet = false; + var frameCount = 0; + var waitForFixedUpdate = new WaitForFixedUpdate(); + m_WaitForLog.Append($"[NetworkManager-{networkManager.LocalClientId}][WaitForTicks-Begin] Waiting for ({tickCount}) network ticks and ({targetFrames}) frames to pass.\n"); + var tickStart = networkManager.NetworkTickSystem.LocalTime.Tick; + while (!tickAndFramesConditionMet) + { + // Wait until both tick and frame counts have reached their targeted values + if ((networkManager.NetworkTickSystem.LocalTime.Tick - tickStart) >= tickCount && frameCount >= targetFrames) + { + tickAndFramesConditionMet = true; + } + else + { + yield return waitForFixedUpdate; + frameCount++; + // In the event something is broken with time systems (or the like) + // Exit if we have exceeded 1000 frames + if (frameCount >= 1000.0f) + { + tickAndFramesConditionMet = true; + } + } + } + m_WaitForLog.Append($"[NetworkManager-{networkManager.LocalClientId}][WaitForTicks-End] Waited for ({networkManager.NetworkTickSystem.LocalTime.Tick - tickStart}) network ticks and ({frameCount}) frames to pass.\n"); + yield break; + } + + /// + /// Yields until specified amount of network ticks and the expected number of frames has been passed. + /// + protected IEnumerator WaitForTicks(NetworkManager networkManager, int count) + { + var targetTick = networkManager.NetworkTickSystem.LocalTime.Tick + count; + + // Calculate the expected number of frame updates that should occur during the tick count wait period + var frameFrequency = 1.0f / (Application.targetFrameRate >= 60 && Application.targetFrameRate <= 100 ? Application.targetFrameRate : 60.0f); + var tickFrequency = 1.0f / networkManager.NetworkConfig.TickRate; + var framesPerTick = tickFrequency / frameFrequency; + + // Total number of frames to occur over the specified number of ticks + var totalFrameCount = framesPerTick * count; + m_WaitForLog.Append($"[NetworkManager-{networkManager.LocalClientId}][WaitForTicks] TickRate ({networkManager.NetworkConfig.TickRate}) | Tick Wait ({count}) | TargetFrameRate ({Application.targetFrameRate}) | Target Frames ({framesPerTick * count})\n"); + yield return WaitForTickAndFrames(networkManager, count, totalFrameCount); + } } } diff --git a/TestHelpers/Runtime/NetcodeIntegrationTestHelpers.cs b/TestHelpers/Runtime/NetcodeIntegrationTestHelpers.cs index 929615b..b360d56 100644 --- a/TestHelpers/Runtime/NetcodeIntegrationTestHelpers.cs +++ b/TestHelpers/Runtime/NetcodeIntegrationTestHelpers.cs @@ -182,11 +182,8 @@ private static void AddUnityTransport(NetworkManager networkManager) unityTransport.ConnectTimeoutMS = 500; // Set the NetworkConfig - networkManager.NetworkConfig = new NetworkConfig() - { - // Set transport - NetworkTransport = unityTransport - }; + networkManager.NetworkConfig ??= new NetworkConfig(); + networkManager.NetworkConfig.NetworkTransport = unityTransport; } public static NetworkManager CreateServer() @@ -486,6 +483,34 @@ public static void MakeNetworkObjectTestPrefab(NetworkObject networkObject, uint } } + public static GameObject CreateNetworkObjectPrefab(string baseName, NetworkManager server, params NetworkManager[] clients) + { + void AddNetworkPrefab(NetworkConfig config, NetworkPrefab prefab) + { + config.Prefabs.Add(prefab); + } + + var prefabCreateAssertError = $"You can only invoke this method before starting the network manager(s)!"; + Assert.IsNotNull(server, prefabCreateAssertError); + Assert.IsFalse(server.IsListening, prefabCreateAssertError); + + var gameObject = new GameObject(); + gameObject.name = baseName; + var networkObject = gameObject.AddComponent(); + networkObject.NetworkManagerOwner = server; + MakeNetworkObjectTestPrefab(networkObject); + var networkPrefab = new NetworkPrefab() { Prefab = gameObject }; + + // We could refactor this test framework to share a NetworkPrefabList instance, but at this point it's + // probably more trouble than it's worth to verify these lists stay in sync across all tests... + AddNetworkPrefab(server.NetworkConfig, networkPrefab); + foreach (var clientNetworkManager in clients) + { + AddNetworkPrefab(clientNetworkManager.NetworkConfig, networkPrefab); + } + return gameObject; + } + // We use GameObject instead of SceneObject to be able to keep hierarchy public static void MarkAsSceneObjectRoot(GameObject networkObjectRoot, NetworkManager server, NetworkManager[] clients) { @@ -512,15 +537,6 @@ public static void MarkAsSceneObjectRoot(GameObject networkObjectRoot, NetworkMa } } - /// - /// Waits (yields) until specified amount of network ticks has been passed. - /// - public static IEnumerator WaitForTicks(NetworkManager networkManager, int count) - { - var targetTick = networkManager.NetworkTickSystem.LocalTime.Tick + count; - yield return new WaitUntil(() => networkManager.NetworkTickSystem.LocalTime.Tick >= targetTick); - } - /// /// Waits on the client side to be connected. /// diff --git a/Tests/Editor/Build/BuildTests.cs b/Tests/Editor/Build/BuildTests.cs index de63ce1..c8cde89 100644 --- a/Tests/Editor/Build/BuildTests.cs +++ b/Tests/Editor/Build/BuildTests.cs @@ -12,7 +12,6 @@ public class BuildTests public const string DefaultBuildScenePath = "Tests/Editor/Build/BuildTestScene.unity"; [Test] - [Ignore("Disabling this test on release/1.2.0 branch due to Burst failures caused when running with upm ci")] public void BasicBuildTest() { var execAssembly = Assembly.GetExecutingAssembly(); diff --git a/Tests/Editor/Messaging/MessageCorruptionTests.cs b/Tests/Editor/Messaging/MessageCorruptionTests.cs new file mode 100644 index 0000000..2b2cf82 --- /dev/null +++ b/Tests/Editor/Messaging/MessageCorruptionTests.cs @@ -0,0 +1,203 @@ +using System; +using System.Collections.Generic; +using System.Text.RegularExpressions; +using NUnit.Framework; +using NUnit.Framework.Internal; +using Unity.Collections; +using Unity.Collections.LowLevel.Unsafe; +using UnityEngine; +using UnityEngine.TestTools; + +namespace Unity.Netcode.EditorTests +{ + public class MessageCorruptionTests + { + + private struct TestMessage : INetworkMessage, INetworkSerializeByMemcpy + { + public ForceNetworkSerializeByMemcpy Value; + public static bool Handled; + public static bool Deserialized; + + public void Serialize(FastBufferWriter writer, int targetVersion) + { + writer.WriteValueSafe(Value); + } + + public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion) + { + Deserialized = true; + reader.ReadValueSafe(out Value); + return true; + } + + public void Handle(ref NetworkContext context) + { + Handled = true; + } + + public int Version => 0; + } + + private class TestMessageProvider : IMessageProvider + { + public List GetMessages() + { + return new List + { + new MessagingSystem.MessageWithHandler + { + MessageType = typeof(TestMessage), + Handler = MessagingSystem.ReceiveMessage, + GetVersion = MessagingSystem.CreateMessageAndGetVersion + } + }; + } + } + + public enum TypeOfCorruption + { + OffsetPlus, + OffsetMinus, + CorruptBytes, + Truncated, + AdditionalGarbageData, + } + + private class TestMessageSender : IMessageSender + { + + public TypeOfCorruption Corruption; + public List MessageQueue = new List(); + + public unsafe void Send(ulong clientId, NetworkDelivery delivery, FastBufferWriter batchData) + { + switch (Corruption) + { + case TypeOfCorruption.OffsetPlus: + { + using var subWriter = new FastBufferWriter(batchData.Length + 1, Allocator.Temp); + subWriter.WriteByteSafe(0); + subWriter.WriteBytesSafe(batchData.GetUnsafePtr(), batchData.Length); + MessageQueue.Add(subWriter.ToArray()); + break; + } + case TypeOfCorruption.OffsetMinus: + { + using var subWriter = new FastBufferWriter(batchData.Length - 1, Allocator.Temp); + subWriter.WriteBytesSafe(batchData.GetUnsafePtr() + 1, batchData.Length - 1); + MessageQueue.Add(subWriter.ToArray()); + break; + } + case TypeOfCorruption.CorruptBytes: + batchData.Seek(batchData.Length - 2); + var currentByte = batchData.GetUnsafePtr()[0]; + batchData.WriteByteSafe((byte)(currentByte == 0 ? 1 : 0)); + MessageQueue.Add(batchData.ToArray()); + break; + case TypeOfCorruption.Truncated: + batchData.Truncate(batchData.Length - 1); + MessageQueue.Add(batchData.ToArray()); + break; + case TypeOfCorruption.AdditionalGarbageData: + batchData.Seek(batchData.Length); + batchData.WriteByteSafe(0); + MessageQueue.Add(batchData.ToArray()); + break; + } + } + } + + private MessagingSystem m_MessagingSystem; + private TestMessageSender m_MessageSender; + + [SetUp] + public void SetUp() + { + TestMessage.Handled = false; + TestMessage.Deserialized = false; + m_MessageSender = new TestMessageSender(); + + m_MessagingSystem = new MessagingSystem(m_MessageSender, this, new TestMessageProvider()); + + m_MessagingSystem.ClientConnected(0); + m_MessagingSystem.SetVersion(0, XXHash.Hash32(typeof(TestMessage).FullName), 0); + } + + [TearDown] + public void TearDown() + { + m_MessagingSystem.Dispose(); + } + + private TestMessage GetMessage() + { + return new TestMessage + { + Value = Guid.NewGuid() + }; + } + + [Test] + public unsafe void WhenPacketsAreCorrupted_TheyDontGetProcessed([Values] TypeOfCorruption typeOfCorruption) + { + m_MessageSender.Corruption = typeOfCorruption; + + switch (typeOfCorruption) + { + case TypeOfCorruption.OffsetMinus: + case TypeOfCorruption.OffsetPlus: + LogAssert.Expect(LogType.Error, new Regex("Received a packet with an invalid Magic Value\\.")); + break; + case TypeOfCorruption.Truncated: + case TypeOfCorruption.AdditionalGarbageData: + LogAssert.Expect(LogType.Error, new Regex("Received a packet with an invalid Batch Size Value\\.")); + break; + case TypeOfCorruption.CorruptBytes: + LogAssert.Expect(LogType.Error, new Regex("Received a packet with an invalid Hash Value\\.")); + break; + } + + // Dummy batch header + var batchHeader = new BatchHeader + { + BatchCount = 1 + }; + var messageHeader = new MessageHeader + { + MessageSize = (ushort)UnsafeUtility.SizeOf(), + MessageType = m_MessagingSystem.GetMessageType(typeof(TestMessage)), + }; + var message = GetMessage(); + + var writer = new FastBufferWriter(1300, Allocator.Temp); + using (writer) + { + writer.TryBeginWrite(FastBufferWriter.GetWriteSize(batchHeader) + + FastBufferWriter.GetWriteSize(messageHeader) + + FastBufferWriter.GetWriteSize(message)); + writer.WriteValue(batchHeader); + writer.WriteValue(messageHeader); + writer.WriteValue(message); + + // Fill out the rest of the batch header + writer.Seek(0); + batchHeader = new BatchHeader + { + Magic = BatchHeader.MagicValue, + BatchSize = writer.Length, + BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)), + BatchCount = 1 + }; + writer.WriteValue(batchHeader); + m_MessageSender.Send(0, NetworkDelivery.Reliable, writer); + + var receivedMessage = m_MessageSender.MessageQueue[0]; + m_MessageSender.MessageQueue.Clear(); + m_MessagingSystem.HandleIncomingData(0, new ArraySegment(receivedMessage), 0); + Assert.IsFalse(TestMessage.Deserialized); + Assert.IsFalse(TestMessage.Handled); + } + } + } +} diff --git a/Tests/Editor/Messaging/MessageCorruptionTests.cs.meta b/Tests/Editor/Messaging/MessageCorruptionTests.cs.meta new file mode 100644 index 0000000..c6b4fc0 --- /dev/null +++ b/Tests/Editor/Messaging/MessageCorruptionTests.cs.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2 +guid: d3c01a0b5a0e478ebc5182fe339bde04 +timeCreated: 1676997550 \ No newline at end of file diff --git a/Tests/Editor/Messaging/MessageReceivingTests.cs b/Tests/Editor/Messaging/MessageReceivingTests.cs index 11c65e7..5112cd0 100644 --- a/Tests/Editor/Messaging/MessageReceivingTests.cs +++ b/Tests/Editor/Messaging/MessageReceivingTests.cs @@ -114,11 +114,11 @@ public void WhenHandlingAMessage_ReceiveMethodIsCalled() } [Test] - public void WhenHandlingIncomingData_ReceiveIsNotCalledBeforeProcessingIncomingMessageQueue() + public unsafe void WhenHandlingIncomingData_ReceiveIsNotCalledBeforeProcessingIncomingMessageQueue() { var batchHeader = new BatchHeader { - BatchSize = 1 + BatchCount = 1 }; var messageHeader = new MessageHeader { @@ -137,6 +137,17 @@ public void WhenHandlingIncomingData_ReceiveIsNotCalledBeforeProcessingIncomingM writer.WriteValue(messageHeader); writer.WriteValue(message); + // Fill out the rest of the batch header + writer.Seek(0); + batchHeader = new BatchHeader + { + Magic = BatchHeader.MagicValue, + BatchSize = writer.Length, + BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)), + BatchCount = 1 + }; + writer.WriteValue(batchHeader); + var reader = new FastBufferReader(writer, Allocator.Temp); using (reader) { @@ -149,11 +160,11 @@ public void WhenHandlingIncomingData_ReceiveIsNotCalledBeforeProcessingIncomingM } [Test] - public void WhenReceivingAMessageAndProcessingMessageQueue_ReceiveMethodIsCalled() + public unsafe void WhenReceivingAMessageAndProcessingMessageQueue_ReceiveMethodIsCalled() { var batchHeader = new BatchHeader { - BatchSize = 1 + BatchCount = 1 }; var messageHeader = new MessageHeader { @@ -170,6 +181,17 @@ public void WhenReceivingAMessageAndProcessingMessageQueue_ReceiveMethodIsCalled BytePacker.WriteValueBitPacked(writer, messageHeader.MessageSize); writer.WriteValueSafe(message); + // Fill out the rest of the batch header + writer.Seek(0); + batchHeader = new BatchHeader + { + Magic = BatchHeader.MagicValue, + BatchSize = writer.Length, + BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)), + BatchCount = 1 + }; + writer.WriteValue(batchHeader); + var reader = new FastBufferReader(writer, Allocator.Temp); using (reader) { @@ -184,11 +206,11 @@ public void WhenReceivingAMessageAndProcessingMessageQueue_ReceiveMethodIsCalled } [Test] - public void WhenReceivingMultipleMessagesAndProcessingMessageQueue_ReceiveMethodIsCalledMultipleTimes() + public unsafe void WhenReceivingMultipleMessagesAndProcessingMessageQueue_ReceiveMethodIsCalledMultipleTimes() { var batchHeader = new BatchHeader { - BatchSize = 2 + BatchCount = 2 }; var messageHeader = new MessageHeader { @@ -209,6 +231,17 @@ public void WhenReceivingMultipleMessagesAndProcessingMessageQueue_ReceiveMethod BytePacker.WriteValueBitPacked(writer, messageHeader.MessageSize); writer.WriteValueSafe(message2); + // Fill out the rest of the batch header + writer.Seek(0); + batchHeader = new BatchHeader + { + Magic = BatchHeader.MagicValue, + BatchSize = writer.Length, + BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)), + BatchCount = 2 + }; + writer.WriteValue(batchHeader); + var reader = new FastBufferReader(writer, Allocator.Temp); using (reader) { diff --git a/Tests/Editor/Messaging/MessageSendingTests.cs b/Tests/Editor/Messaging/MessageSendingTests.cs index 66f398a..e586b79 100644 --- a/Tests/Editor/Messaging/MessageSendingTests.cs +++ b/Tests/Editor/Messaging/MessageSendingTests.cs @@ -155,7 +155,7 @@ public void WhenNotExceedingBatchSize_NewBatchesAreNotCreated() { var message = GetMessage(); var size = UnsafeUtility.SizeOf() + 2; // MessageHeader packed with this message will be 2 bytes - for (var i = 0; i < 1300 / size; ++i) + for (var i = 0; i < (1300 - UnsafeUtility.SizeOf()) / size; ++i) { m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients); } @@ -169,7 +169,7 @@ public void WhenExceedingBatchSize_NewBatchesAreCreated() { var message = GetMessage(); var size = UnsafeUtility.SizeOf() + 2; // MessageHeader packed with this message will be 2 bytes - for (var i = 0; i < (1300 / size) + 1; ++i) + for (var i = 0; i < ((1300 - UnsafeUtility.SizeOf()) / size) + 1; ++i) { m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients); } @@ -183,7 +183,7 @@ public void WhenExceedingMTUSizeWithFragmentedDelivery_NewBatchesAreNotCreated() { var message = GetMessage(); var size = UnsafeUtility.SizeOf() + 2; // MessageHeader packed with this message will be 2 bytes - for (var i = 0; i < (1300 / size) + 1; ++i) + for (var i = 0; i < ((1300 - UnsafeUtility.SizeOf()) / size) + 1; ++i) { m_MessagingSystem.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, m_Clients); } @@ -229,7 +229,7 @@ public void WhenSendingMessaged_SentDataIsCorrect() using (reader) { reader.ReadValueSafe(out BatchHeader header); - Assert.AreEqual(2, header.BatchSize); + Assert.AreEqual(2, header.BatchCount); MessageHeader messageHeader; diff --git a/Tests/Editor/NetworkManagerConfigurationTests.cs b/Tests/Editor/NetworkManagerConfigurationTests.cs index ac3fccb..5529e4d 100644 --- a/Tests/Editor/NetworkManagerConfigurationTests.cs +++ b/Tests/Editor/NetworkManagerConfigurationTests.cs @@ -1,6 +1,8 @@ +using System.Collections.Generic; using NUnit.Framework; using UnityEngine; using Unity.Netcode.Editor; +using Unity.Netcode.Transports.UTP; using UnityEditor.SceneManagement; using UnityEngine.SceneManagement; using UnityEngine.TestTools; @@ -105,12 +107,188 @@ public void NestedNetworkObjectPrefabCheck() networkManager.OnValidate(); // Expect a warning - LogAssert.Expect(LogType.Warning, $"[Netcode] {NetworkManager.PrefabDebugHelper(networkManager.NetworkConfig.NetworkPrefabs[0])} has child {nameof(NetworkObject)}(s) but they will not be spawned across the network (unsupported {nameof(NetworkPrefab)} setup)"); + LogAssert.Expect(LogType.Warning, $"[Netcode] {NetworkManager.PrefabDebugHelper(networkManager.NetworkConfig.Prefabs.Prefabs[0])} has child {nameof(NetworkObject)}(s) but they will not be spawned across the network (unsupported {nameof(NetworkPrefab)} setup)"); // Clean up Object.DestroyImmediate(networkManagerObject); Object.DestroyImmediate(parent); } + + [Test] + public void WhenNetworkConfigContainsOldPrefabList_TheyMigrateProperlyToTheNewList() + { + var networkConfig = new NetworkConfig(); + + var regularPrefab = new GameObject("Regular Prefab").AddComponent(); + var overriddenPrefab = new GameObject("Overridden Prefab").AddComponent(); + var overridingTargetPrefab = new GameObject("Overriding Target Prefab").AddComponent(); + var sourcePrefabToOverride = new GameObject("Overriding Source Prefab").AddComponent(); + + regularPrefab.GlobalObjectIdHash = 1; + overriddenPrefab.GlobalObjectIdHash = 2; + overridingTargetPrefab.GlobalObjectIdHash = 3; + sourcePrefabToOverride.GlobalObjectIdHash = 4; + + networkConfig.OldPrefabList = new List(); + networkConfig.OldPrefabList.Add(new NetworkPrefab { Prefab = regularPrefab.gameObject }); + networkConfig.OldPrefabList.Add(new NetworkPrefab { Prefab = overriddenPrefab.gameObject, Override = NetworkPrefabOverride.Prefab, OverridingTargetPrefab = overridingTargetPrefab.gameObject, SourcePrefabToOverride = sourcePrefabToOverride.gameObject, SourceHashToOverride = 123456 }); + + networkConfig.InitializePrefabs(); + + Assert.IsNull(networkConfig.OldPrefabList); + Assert.IsNotNull(networkConfig.Prefabs); + Assert.IsNotNull(networkConfig.Prefabs.Prefabs); + Assert.AreEqual(2, networkConfig.Prefabs.Prefabs.Count); + + Assert.AreSame(regularPrefab.gameObject, networkConfig.Prefabs.Prefabs[0].Prefab); + Assert.AreEqual(NetworkPrefabOverride.None, networkConfig.Prefabs.Prefabs[0].Override); + Assert.IsNull(networkConfig.Prefabs.Prefabs[0].SourcePrefabToOverride); + Assert.IsNull(networkConfig.Prefabs.Prefabs[0].OverridingTargetPrefab); + + Assert.AreSame(overriddenPrefab.gameObject, networkConfig.Prefabs.Prefabs[1].Prefab); + Assert.AreEqual(NetworkPrefabOverride.Prefab, networkConfig.Prefabs.Prefabs[1].Override); + Assert.AreEqual(123456, networkConfig.Prefabs.Prefabs[1].SourceHashToOverride); + Assert.AreSame(sourcePrefabToOverride.gameObject, networkConfig.Prefabs.Prefabs[1].SourcePrefabToOverride); + Assert.AreSame(overridingTargetPrefab.gameObject, networkConfig.Prefabs.Prefabs[1].OverridingTargetPrefab); + } + + [Test] + public void WhenModifyingPrefabListUsingNetworkManagerAPI_ModificationIsLocal() + { + // Setup + var networkManagerObject = new GameObject(nameof(NestedNetworkObjectPrefabCheck)); + var networkManager = networkManagerObject.AddComponent(); + networkManager.NetworkConfig = new NetworkConfig(); + networkManager.NetworkConfig.NetworkTransport = networkManager.gameObject.AddComponent(); + + var networkManagerObject2 = new GameObject(nameof(NestedNetworkObjectPrefabCheck)); + var networkManager2 = networkManagerObject2.AddComponent(); + networkManager2.NetworkConfig = new NetworkConfig(); + networkManager2.NetworkConfig.NetworkTransport = networkManager.gameObject.AddComponent(); + + var object1 = new GameObject("Object 1").AddComponent(); + var object2 = new GameObject("Object 2").AddComponent(); + var object3 = new GameObject("Object 3").AddComponent(); + + object1.GlobalObjectIdHash = 1; + object2.GlobalObjectIdHash = 2; + object3.GlobalObjectIdHash = 3; + + var sharedList = ScriptableObject.CreateInstance(); + sharedList.List.Add(new NetworkPrefab { Prefab = object1.gameObject }); + + networkManager.NetworkConfig.Prefabs.NetworkPrefabsLists = new List { sharedList }; + networkManager2.NetworkConfig.Prefabs.NetworkPrefabsLists = new List { sharedList }; + + networkManager.Initialize(true); + networkManager2.Initialize(false); + + networkManager.AddNetworkPrefab(object2.gameObject); + networkManager2.AddNetworkPrefab(object3.gameObject); + + Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object1.gameObject)); + Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object1.gameObject)); + Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object2.gameObject)); + Assert.IsFalse(networkManager2.NetworkConfig.Prefabs.Contains(object2.gameObject)); + Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object3.gameObject)); + Assert.IsFalse(networkManager.NetworkConfig.Prefabs.Contains(object3.gameObject)); + + Assert.IsTrue(sharedList.Contains(object1.gameObject)); + Assert.IsFalse(sharedList.Contains(object2.gameObject)); + Assert.IsFalse(sharedList.Contains(object3.gameObject)); + } + + [Test] + public void WhenModifyingPrefabListUsingPrefabsAPI_ModificationIsLocal() + { + // Setup + var networkManagerObject = new GameObject(nameof(NestedNetworkObjectPrefabCheck)); + var networkManager = networkManagerObject.AddComponent(); + networkManager.NetworkConfig = new NetworkConfig(); + networkManager.NetworkConfig.NetworkTransport = networkManager.gameObject.AddComponent(); + + var networkManagerObject2 = new GameObject(nameof(NestedNetworkObjectPrefabCheck)); + var networkManager2 = networkManagerObject2.AddComponent(); + networkManager2.NetworkConfig = new NetworkConfig(); + networkManager2.NetworkConfig.NetworkTransport = networkManager.gameObject.AddComponent(); + + var object1 = new GameObject("Object 1").AddComponent(); + var object2 = new GameObject("Object 2").AddComponent(); + var object3 = new GameObject("Object 3").AddComponent(); + + object1.GlobalObjectIdHash = 1; + object2.GlobalObjectIdHash = 2; + object3.GlobalObjectIdHash = 3; + + var sharedList = ScriptableObject.CreateInstance(); + sharedList.List.Add(new NetworkPrefab { Prefab = object1.gameObject }); + + networkManager.NetworkConfig.Prefabs.NetworkPrefabsLists = new List { sharedList }; + networkManager2.NetworkConfig.Prefabs.NetworkPrefabsLists = new List { sharedList }; + + networkManager.Initialize(true); + networkManager2.Initialize(false); + + networkManager.NetworkConfig.Prefabs.Add(new NetworkPrefab { Prefab = object2.gameObject }); + networkManager2.NetworkConfig.Prefabs.Add(new NetworkPrefab { Prefab = object3.gameObject }); + + Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object1.gameObject)); + Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object1.gameObject)); + Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object2.gameObject)); + Assert.IsFalse(networkManager2.NetworkConfig.Prefabs.Contains(object2.gameObject)); + Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object3.gameObject)); + Assert.IsFalse(networkManager.NetworkConfig.Prefabs.Contains(object3.gameObject)); + + Assert.IsTrue(sharedList.Contains(object1.gameObject)); + Assert.IsFalse(sharedList.Contains(object2.gameObject)); + Assert.IsFalse(sharedList.Contains(object3.gameObject)); + } + + [Test] + public void WhenModifyingPrefabListUsingPrefabsListAPI_ModificationIsShared() + { + // Setup + var networkManagerObject = new GameObject(nameof(NestedNetworkObjectPrefabCheck)); + var networkManager = networkManagerObject.AddComponent(); + networkManager.NetworkConfig = new NetworkConfig(); + networkManager.NetworkConfig.NetworkTransport = networkManager.gameObject.AddComponent(); + + var networkManagerObject2 = new GameObject(nameof(NestedNetworkObjectPrefabCheck)); + var networkManager2 = networkManagerObject2.AddComponent(); + networkManager2.NetworkConfig = new NetworkConfig(); + networkManager2.NetworkConfig.NetworkTransport = networkManager.gameObject.AddComponent(); + + var object1 = new GameObject("Object 1").AddComponent(); + var object2 = new GameObject("Object 2").AddComponent(); + var object3 = new GameObject("Object 3").AddComponent(); + + object1.GlobalObjectIdHash = 1; + object2.GlobalObjectIdHash = 2; + object3.GlobalObjectIdHash = 3; + + var sharedList = ScriptableObject.CreateInstance(); + sharedList.List.Add(new NetworkPrefab { Prefab = object1.gameObject }); + + networkManager.NetworkConfig.Prefabs.NetworkPrefabsLists = new List { sharedList }; + networkManager2.NetworkConfig.Prefabs.NetworkPrefabsLists = new List { sharedList }; + + networkManager.Initialize(true); + networkManager2.Initialize(false); + + networkManager.NetworkConfig.Prefabs.NetworkPrefabsLists[0].Add(new NetworkPrefab { Prefab = object2.gameObject }); + networkManager2.NetworkConfig.Prefabs.NetworkPrefabsLists[0].Add(new NetworkPrefab { Prefab = object3.gameObject }); + + Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object1.gameObject)); + Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object1.gameObject)); + Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object2.gameObject)); + Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object2.gameObject)); + Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object3.gameObject)); + Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object3.gameObject)); + + Assert.IsTrue(sharedList.Contains(object1.gameObject)); + Assert.IsTrue(sharedList.Contains(object2.gameObject)); + Assert.IsTrue(sharedList.Contains(object3.gameObject)); + } } } diff --git a/Tests/Editor/NetworkPrefabProcessorTests.cs b/Tests/Editor/NetworkPrefabProcessorTests.cs new file mode 100644 index 0000000..9af7fe4 --- /dev/null +++ b/Tests/Editor/NetworkPrefabProcessorTests.cs @@ -0,0 +1,90 @@ +using NUnit.Framework; +using UnityEngine; +using Unity.Netcode.Editor.Configuration; +using UnityEditor; + +namespace Unity.Netcode.EditorTests +{ + public class NetworkPrefabProcessorTests + { + private NetcodeForGameObjectsProjectSettings m_Settings; + private bool m_EditorDefaultPrefabSetting; + private string m_EditorDefaultPrefabLocation; + + private GameObject m_Prefab; + + private const string k_PrefabName = "Assets/TestPrefab.prefab"; + private const string k_DefaultAssetString = "Assets/TestPrefabList.asset"; + + [SetUp] + public void SetUp() + { + m_Settings = NetcodeForGameObjectsProjectSettings.instance; + m_EditorDefaultPrefabSetting = m_Settings.GenerateDefaultNetworkPrefabs; + m_EditorDefaultPrefabLocation = NetworkPrefabProcessor.DefaultNetworkPrefabsPath; + NetworkPrefabProcessor.DefaultNetworkPrefabsPath = k_DefaultAssetString; + } + + [TearDown] + public void TearDown() + { + m_Settings.GenerateDefaultNetworkPrefabs = m_EditorDefaultPrefabSetting; + NetworkPrefabProcessor.DefaultNetworkPrefabsPath = m_EditorDefaultPrefabLocation; + AssetDatabase.DeleteAsset(k_PrefabName); + AssetDatabase.DeleteAsset(k_DefaultAssetString); + } + + [Test] + public void WhenGenerateDefaultNetworkPrefabsIsEnabled_AddingAPrefabUpdatesDefaultPrefabList() + { + var obj = new GameObject("Object"); + obj.AddComponent(); + m_Settings.GenerateDefaultNetworkPrefabs = true; + m_Prefab = PrefabUtility.SaveAsPrefabAsset(obj, k_PrefabName); + Object.DestroyImmediate(obj); + + var prefabList = NetworkPrefabProcessor.GetOrCreateNetworkPrefabs(NetworkPrefabProcessor.DefaultNetworkPrefabsPath, out var isNew, false); + Assert.IsFalse(isNew); + Assert.IsTrue(prefabList.Contains(m_Prefab)); + } + + [Test] + public void WhenGenerateDefaultNetworkPrefabsIsEnabled_RemovingAPrefabUpdatesDefaultPrefabList() + { + WhenGenerateDefaultNetworkPrefabsIsEnabled_AddingAPrefabUpdatesDefaultPrefabList(); + + AssetDatabase.DeleteAsset(k_PrefabName); + var prefabList = NetworkPrefabProcessor.GetOrCreateNetworkPrefabs(NetworkPrefabProcessor.DefaultNetworkPrefabsPath, out var isNew, false); + Assert.IsFalse(isNew); + Assert.IsFalse(prefabList.Contains(m_Prefab)); + } + + [Test] + public void WhenGenerateDefaultNetworkPrefabsIsNotEnabled_AddingAPrefabDoesNotUpdateDefaultPrefabList() + { + var obj = new GameObject("Object"); + obj.AddComponent(); + m_Settings.GenerateDefaultNetworkPrefabs = false; + m_Prefab = PrefabUtility.SaveAsPrefabAsset(obj, k_PrefabName); + Object.DestroyImmediate(obj); + + var prefabList = NetworkPrefabProcessor.GetOrCreateNetworkPrefabs(NetworkPrefabProcessor.DefaultNetworkPrefabsPath, out var isNew, false); + Assert.IsTrue(isNew); + Assert.IsFalse(prefabList.Contains(m_Prefab)); + } + + [Test] + public void WhenGenerateDefaultNetworkPrefabsIsNotEnabled_RemovingAPrefabDoesNotUpdateDefaultPrefabList() + { + // Add it with the list enabled, then disable the list. Removing it + // should then be nop. + WhenGenerateDefaultNetworkPrefabsIsEnabled_AddingAPrefabUpdatesDefaultPrefabList(); + + m_Settings.GenerateDefaultNetworkPrefabs = false; + AssetDatabase.DeleteAsset(k_PrefabName); + var prefabList = NetworkPrefabProcessor.GetOrCreateNetworkPrefabs(NetworkPrefabProcessor.DefaultNetworkPrefabsPath, out var isNew, false); + Assert.IsFalse(isNew); + Assert.IsTrue(prefabList.Contains(m_Prefab)); + } + } +} diff --git a/Tests/Editor/NetworkPrefabProcessorTests.cs.meta b/Tests/Editor/NetworkPrefabProcessorTests.cs.meta new file mode 100644 index 0000000..c95423a --- /dev/null +++ b/Tests/Editor/NetworkPrefabProcessorTests.cs.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2 +guid: 6471efe05b0548ef9d2171e07d4a561b +timeCreated: 1669140101 \ No newline at end of file diff --git a/Tests/Editor/Transports/BatchedSendQueueTests.cs b/Tests/Editor/Transports/BatchedSendQueueTests.cs index eac6b73..3438c60 100644 --- a/Tests/Editor/Transports/BatchedSendQueueTests.cs +++ b/Tests/Editor/Transports/BatchedSendQueueTests.cs @@ -229,6 +229,12 @@ public void BatchedSendQueue_FillWriterWithMessages_PartialPushedMessages() var writer = new DataStreamWriter(data); Assert.AreEqual(messageLength, q.FillWriterWithMessages(ref writer)); AssertIsTestMessage(data); + + q.Consume(messageLength); + + writer = new DataStreamWriter(data); + Assert.AreEqual(messageLength, q.FillWriterWithMessages(ref writer)); + AssertIsTestMessage(data); } [Test] diff --git a/Tests/Editor/Transports/UnityTransportTests.cs b/Tests/Editor/Transports/UnityTransportTests.cs index 5303974..660b05b 100644 --- a/Tests/Editor/Transports/UnityTransportTests.cs +++ b/Tests/Editor/Transports/UnityTransportTests.cs @@ -115,13 +115,29 @@ public void UnityTransport_RestartSucceedsAfterFailure() UnityTransport transport = new GameObject().AddComponent(); transport.Initialize(); - transport.SetConnectionData("127.0.0.", 4242); + transport.SetConnectionData("127.0.0.", 4242, "127.0.0."); Assert.False(transport.StartServer()); LogAssert.Expect(LogType.Error, "Invalid network endpoint: 127.0.0.:4242."); - LogAssert.Expect(LogType.Error, "Server failed to bind"); +#if UTP_TRANSPORT_2_0_ABOVE + LogAssert.Expect(LogType.Error, "Socket creation failed (error Unity.Baselib.LowLevel.Binding+Baselib_ErrorState: Invalid argument (0x01000003) "); +#endif + LogAssert.Expect(LogType.Error, "Server failed to bind. This is usually caused by another process being bound to the same port."); + + transport.SetConnectionData("127.0.0.1", 4242, "127.0.0.1"); + Assert.True(transport.StartServer()); + + transport.Shutdown(); + } + + // Check that leaving all addresses empty is valid. + [Test] + public void UnityTransport_StartServerWithoutAddresses() + { + UnityTransport transport = new GameObject().AddComponent(); + transport.Initialize(); - transport.SetConnectionData("127.0.0.1", 4242); + transport.SetConnectionData(string.Empty, 4242); Assert.True(transport.StartServer()); transport.Shutdown(); diff --git a/Tests/Runtime/AssemblyInfo.cs b/Tests/Runtime/AssemblyInfo.cs index f3cdeaf..fb444ea 100644 --- a/Tests/Runtime/AssemblyInfo.cs +++ b/Tests/Runtime/AssemblyInfo.cs @@ -1,5 +1,11 @@ using System.Runtime.CompilerServices; -[assembly: InternalsVisibleTo("TestProject.EditorTests")] +#if UNITY_INCLUDE_TESTS [assembly: InternalsVisibleTo("TestProject.RuntimeTests")] +#if UNITY_EDITOR +[assembly: InternalsVisibleTo("TestProject.EditorTests")] +#endif // UNITY_EDITOR +#if MULTIPLAYER_TOOLS [assembly: InternalsVisibleTo("TestProject.ToolsIntegration.RuntimeTests")] +#endif // MULTIPLAYER_TOOLS +#endif // UNITY_INCLUDE_TESTS diff --git a/Tests/Runtime/InvalidConnectionEventsTest.cs b/Tests/Runtime/InvalidConnectionEventsTest.cs new file mode 100644 index 0000000..6ae6c59 --- /dev/null +++ b/Tests/Runtime/InvalidConnectionEventsTest.cs @@ -0,0 +1,167 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using System.Text.RegularExpressions; +using NUnit.Framework; +using Unity.Collections; +using UnityEngine.TestTools; +using Unity.Netcode.TestHelpers.Runtime; +using UnityEngine; +using Debug = UnityEngine.Debug; + +namespace Unity.Netcode.RuntimeTests +{ + public class InvalidConnectionEventsTest : NetcodeIntegrationTest + { + protected override int NumberOfClients => 1; + + public InvalidConnectionEventsTest() : base(HostOrServer.Server) { } + + private class Hooks : INetworkHooks + { + public void OnBeforeSendMessage(ulong clientId, ref T message, NetworkDelivery delivery) where T : INetworkMessage + { + } + + public void OnAfterSendMessage(ulong clientId, ref T message, NetworkDelivery delivery, int messageSizeBytes) where T : INetworkMessage + { + } + + public void OnBeforeReceiveMessage(ulong senderId, Type messageType, int messageSizeBytes) + { + } + + public void OnAfterReceiveMessage(ulong senderId, Type messageType, int messageSizeBytes) + { + } + + public void OnBeforeSendBatch(ulong clientId, int messageCount, int batchSizeInBytes, NetworkDelivery delivery) + { + } + + public void OnAfterSendBatch(ulong clientId, int messageCount, int batchSizeInBytes, NetworkDelivery delivery) + { + } + + public void OnBeforeReceiveBatch(ulong senderId, int messageCount, int batchSizeInBytes) + { + } + + public void OnAfterReceiveBatch(ulong senderId, int messageCount, int batchSizeInBytes) + { + } + + public bool OnVerifyCanSend(ulong destinationId, Type messageType, NetworkDelivery delivery) + { + return true; + } + + public bool OnVerifyCanReceive(ulong senderId, Type messageType, FastBufferReader messageContent, ref NetworkContext context) + { + return true; + } + + public void OnBeforeHandleMessage(ref T message, ref NetworkContext context) where T : INetworkMessage + { + if (typeof(T) == typeof(TCatchType)) + { + Debug.Log("Woompa"); + Assert.Fail($"{typeof(T).Name} was received when it should not have been."); + } + } + + public void OnAfterHandleMessage(ref T message, ref NetworkContext context) where T : INetworkMessage + { + } + } + + [UnityTest] + public IEnumerator WhenSendingConnectionApprovedToAlreadyConnectedClient_ConnectionApprovedMessageIsRejected() + { + var message = new ConnectionApprovedMessage(); + m_ServerNetworkManager.SendMessage(ref message, NetworkDelivery.Reliable, m_ClientNetworkManagers[0].LocalClientId); + + // Unnamed message is something to wait for. When this one is received, + // we know the above one has also reached its destination. + var writer = new FastBufferWriter(1, Allocator.Temp); + using (writer) + { + writer.WriteByteSafe(0); + m_ServerNetworkManager.CustomMessagingManager.SendUnnamedMessage(m_ClientNetworkManagers[0].LocalClientId, writer); + } + + m_ClientNetworkManagers[0].MessagingSystem.Hook(new Hooks()); + + LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionApprovedMessage)} was received from the server when the connection has already been established\\. This should not happen\\.")); + + yield return WaitForMessageReceived(m_ClientNetworkManagers.ToList()); + } + + [UnityTest] + public IEnumerator WhenSendingConnectionRequestToAnyClient_ConnectionRequestMessageIsRejected() + { + var message = new ConnectionRequestMessage(); + m_ServerNetworkManager.SendMessage(ref message, NetworkDelivery.Reliable, m_ClientNetworkManagers[0].LocalClientId); + + // Unnamed message is something to wait for. When this one is received, + // we know the above one has also reached its destination. + var writer = new FastBufferWriter(1, Allocator.Temp); + using (writer) + { + writer.WriteByteSafe(0); + m_ServerNetworkManager.CustomMessagingManager.SendUnnamedMessage(m_ClientNetworkManagers[0].LocalClientId, writer); + } + + m_ClientNetworkManagers[0].MessagingSystem.Hook(new Hooks()); + + LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionRequestMessage)} was received from the server on the client side\\. This should not happen\\.")); + + yield return WaitForMessageReceived(m_ClientNetworkManagers.ToList()); + } + + [UnityTest] + public IEnumerator WhenSendingConnectionRequestFromAlreadyConnectedClient_ConnectionRequestMessageIsRejected() + { + var message = new ConnectionRequestMessage(); + m_ClientNetworkManagers[0].SendMessage(ref message, NetworkDelivery.Reliable, m_ServerNetworkManager.LocalClientId); + + // Unnamed message is something to wait for. When this one is received, + // we know the above one has also reached its destination. + var writer = new FastBufferWriter(1, Allocator.Temp); + using (writer) + { + writer.WriteByteSafe(0); + m_ClientNetworkManagers[0].CustomMessagingManager.SendUnnamedMessage(m_ServerNetworkManager.LocalClientId, writer); + } + + m_ServerNetworkManager.MessagingSystem.Hook(new Hooks()); + + LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionRequestMessage)} was received from a client when the connection has already been established\\. This should not happen\\.")); + + yield return WaitForMessageReceived(new List { m_ServerNetworkManager }); + } + + [UnityTest] + public IEnumerator WhenSendingConnectionApprovedFromAnyClient_ConnectionApprovedMessageIsRejected() + { + var message = new ConnectionApprovedMessage(); + m_ClientNetworkManagers[0].SendMessage(ref message, NetworkDelivery.Reliable, m_ServerNetworkManager.LocalClientId); + + // Unnamed message is something to wait for. When this one is received, + // we know the above one has also reached its destination. + var writer = new FastBufferWriter(1, Allocator.Temp); + using (writer) + { + writer.WriteByteSafe(0); + m_ClientNetworkManagers[0].CustomMessagingManager.SendUnnamedMessage(m_ServerNetworkManager.LocalClientId, writer); + } + + m_ServerNetworkManager.MessagingSystem.Hook(new Hooks()); + + LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionApprovedMessage)} was received from a client on the server side\\. This should not happen\\.")); + + yield return WaitForMessageReceived(new List { m_ServerNetworkManager }); + } + } +} diff --git a/Tests/Runtime/InvalidConnectionEventsTest.cs.meta b/Tests/Runtime/InvalidConnectionEventsTest.cs.meta new file mode 100644 index 0000000..b9c2b32 --- /dev/null +++ b/Tests/Runtime/InvalidConnectionEventsTest.cs.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2 +guid: c30dd8c697274dd195f0fa8b86a4cf9d +timeCreated: 1677003739 \ No newline at end of file diff --git a/Tests/Runtime/Metrics/OwnershipChangeMetricsTests.cs b/Tests/Runtime/Metrics/OwnershipChangeMetricsTests.cs index a13adac..a3fcf30 100644 --- a/Tests/Runtime/Metrics/OwnershipChangeMetricsTests.cs +++ b/Tests/Runtime/Metrics/OwnershipChangeMetricsTests.cs @@ -25,10 +25,10 @@ protected override void OnServerAndClientsCreated() NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(m_NewNetworkPrefab); var networkPrefab = new NetworkPrefab { Prefab = gameObject }; - m_ServerNetworkManager.NetworkConfig.NetworkPrefabs.Add(networkPrefab); + m_ServerNetworkManager.NetworkConfig.Prefabs.Add(networkPrefab); foreach (var client in m_ClientNetworkManagers) { - client.NetworkConfig.NetworkPrefabs.Add(networkPrefab); + client.NetworkConfig.Prefabs.Add(networkPrefab); } base.OnServerAndClientsCreated(); } diff --git a/Tests/Runtime/NetworkBehaviourGenericTests.cs b/Tests/Runtime/NetworkBehaviourGenericTests.cs index c51527a..1d8dd76 100644 --- a/Tests/Runtime/NetworkBehaviourGenericTests.cs +++ b/Tests/Runtime/NetworkBehaviourGenericTests.cs @@ -1,5 +1,6 @@ using System.Collections; using UnityEngine; +using NUnit.Framework; using UnityEngine.TestTools; using Unity.Netcode.TestHelpers.Runtime; using Unity.Netcode.Components; @@ -147,5 +148,35 @@ public IEnumerator ValidateDeleteChildNetworkBehaviour() // (validating the fix) Object.Destroy(parentObject); } + + protected override void OnPlayerPrefabGameObjectCreated() + { + // Adds the SimpleNetworkBehaviour before the NetworkObject + // for OnNetworkDespawnInvokedWhenClientDisconnects testing + m_PlayerPrefab.AddComponent(); + } + + /// + /// This validates that upon a client disconnecting, the server-side + /// client's player clone will invoke NetworkBehaviour.OnNetworkDespawn + /// when the component precedes the NetworkObject component.(PR-2323) + /// + [UnityTest] + public IEnumerator OnNetworkDespawnInvokedWhenClientDisconnects() + { + m_AllowServerToStart = true; + + // Now just start the Host + yield return StartServerAndClients(); + + // Now create and connect a new client + yield return CreateAndStartNewClient(); + + var serverSidePlayer = m_PlayerNetworkObjects[NetworkManager.ServerClientId][m_ClientNetworkManagers[0].LocalClientId].GetComponent(); + + yield return StopOneClient(m_ClientNetworkManagers[0]); + + Assert.True(serverSidePlayer.OnNetworkDespawnCalled, $"Server-side player clone did not invoke OnNetworkDespawn!"); + } } } diff --git a/Tests/Runtime/NetworkBehaviourUpdaterTests.cs b/Tests/Runtime/NetworkBehaviourUpdaterTests.cs index 21bfd10..c51a195 100644 --- a/Tests/Runtime/NetworkBehaviourUpdaterTests.cs +++ b/Tests/Runtime/NetworkBehaviourUpdaterTests.cs @@ -183,6 +183,11 @@ protected override bool CanStartServerAndClients() /// private IEnumerator StartClientsAndServer(bool useHost, int numberOfClients, GameObject prefabObject) { + void AddNetworkPrefab(NetworkConfig config, NetworkPrefab prefab) + { + config.Prefabs.Add(prefab); + } + // Sanity check to make sure we are not trying to create more clients than we have available to use Assert.True(numberOfClients <= m_ClientNetworkManagers.Length); m_ActiveClientsForCurrentTest = new List(); @@ -194,12 +199,13 @@ private IEnumerator StartClientsAndServer(bool useHost, int numberOfClients, Gam } // Add the prefab to be used for this particular test iteration - m_ServerNetworkManager.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Prefab = prefabObject }); + var np = new NetworkPrefab { Prefab = prefabObject }; + AddNetworkPrefab(m_ServerNetworkManager.NetworkConfig, np); m_ServerNetworkManager.NetworkConfig.TickRate = 30; foreach (var clientManager in m_ActiveClientsForCurrentTest) { m_ServerNetworkManager.NetworkConfig.TickRate = 30; - clientManager.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Prefab = prefabObject }); + AddNetworkPrefab(clientManager.NetworkConfig, np); } // Now spin everything up normally diff --git a/Tests/Runtime/NetworkObject/NetworkObjectNetworkClientOwnedObjectsTests.cs b/Tests/Runtime/NetworkObject/NetworkObjectNetworkClientOwnedObjectsTests.cs index bdd1623..1043a88 100644 --- a/Tests/Runtime/NetworkObject/NetworkObjectNetworkClientOwnedObjectsTests.cs +++ b/Tests/Runtime/NetworkObject/NetworkObjectNetworkClientOwnedObjectsTests.cs @@ -15,32 +15,18 @@ private class DummyNetworkBehaviour : NetworkBehaviour } protected override int NumberOfClients => 1; - private NetworkPrefab m_NetworkPrefab; + private GameObject m_NetworkObject; + protected override void OnServerAndClientsCreated() { - // create prefab - var gameObject = new GameObject("ClientOwnedObject"); - var networkObject = gameObject.AddComponent(); - gameObject.AddComponent(); - NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(networkObject); - - m_NetworkPrefab = (new NetworkPrefab() - { - Prefab = gameObject - }); - - m_ServerNetworkManager.NetworkConfig.NetworkPrefabs.Add(m_NetworkPrefab); - - foreach (var client in m_ClientNetworkManagers) - { - client.NetworkConfig.NetworkPrefabs.Add(m_NetworkPrefab); - } + m_NetworkObject = CreateNetworkObjectPrefab("ClientOwnedObject"); + m_NetworkObject.gameObject.AddComponent(); } [UnityTest] public IEnumerator ChangeOwnershipOwnedObjectsAddTest() { - NetworkObject serverObject = Object.Instantiate(m_NetworkPrefab.Prefab).GetComponent(); + NetworkObject serverObject = m_NetworkObject.GetComponent(); serverObject.NetworkManagerOwner = m_ServerNetworkManager; serverObject.Spawn(); @@ -64,7 +50,7 @@ public IEnumerator ChangeOwnershipOwnedObjectsAddTest() [UnityTest] public IEnumerator WhenOwnershipIsChanged_OwnershipValuesUpdateCorrectly() { - NetworkObject serverObject = Object.Instantiate(m_NetworkPrefab.Prefab).GetComponent(); + NetworkObject serverObject = m_NetworkObject.GetComponent(); serverObject.NetworkManagerOwner = m_ServerNetworkManager; serverObject.Spawn(); diff --git a/Tests/Runtime/NetworkObject/NetworkObjectOnNetworkDespawnTests.cs b/Tests/Runtime/NetworkObject/NetworkObjectOnNetworkDespawnTests.cs index 94f1618..c3ef58e 100644 --- a/Tests/Runtime/NetworkObject/NetworkObjectOnNetworkDespawnTests.cs +++ b/Tests/Runtime/NetworkObject/NetworkObjectOnNetworkDespawnTests.cs @@ -40,21 +40,9 @@ public IEnumerator Setup() { Assert.IsTrue(NetcodeIntegrationTestHelpers.Create(1, out m_ServerHost, out m_Clients)); - m_ObjectToSpawn = new GameObject(); - m_NetworkObject = m_ObjectToSpawn.AddComponent(); + m_ObjectToSpawn = NetcodeIntegrationTestHelpers.CreateNetworkObjectPrefab(nameof(NetworkObjectOnNetworkDespawnTests), m_ServerHost, m_Clients); m_ObjectToSpawn.AddComponent(); - - // Make it a prefab - NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(m_NetworkObject); - - var networkPrefab = new NetworkPrefab(); - networkPrefab.Prefab = m_ObjectToSpawn; - m_ServerHost.NetworkConfig.NetworkPrefabs.Add(networkPrefab); - - foreach (var client in m_Clients) - { - client.NetworkConfig.NetworkPrefabs.Add(networkPrefab); - } + m_NetworkObject = m_ObjectToSpawn.GetComponent(); yield return null; } @@ -130,4 +118,3 @@ public IEnumerator TestNetworkObjectDespawnOnShutdown([Values(InstanceType.Serve } } } - diff --git a/Tests/Runtime/NetworkObject/NetworkObjectSpawnManyObjectsTests.cs b/Tests/Runtime/NetworkObject/NetworkObjectSpawnManyObjectsTests.cs index 9eedf8f..956ca61 100644 --- a/Tests/Runtime/NetworkObject/NetworkObjectSpawnManyObjectsTests.cs +++ b/Tests/Runtime/NetworkObject/NetworkObjectSpawnManyObjectsTests.cs @@ -39,10 +39,10 @@ protected override void OnServerAndClientsCreated() m_PrefabToSpawn = new NetworkPrefab() { Prefab = gameObject }; - m_ServerNetworkManager.NetworkConfig.NetworkPrefabs.Add(m_PrefabToSpawn); + m_ServerNetworkManager.NetworkConfig.Prefabs.Add(m_PrefabToSpawn); foreach (var client in m_ClientNetworkManagers) { - client.NetworkConfig.NetworkPrefabs.Add(m_PrefabToSpawn); + client.NetworkConfig.Prefabs.Add(m_PrefabToSpawn); } } diff --git a/Tests/Runtime/NetworkObject/NetworkObjectSynchronizationTests.cs b/Tests/Runtime/NetworkObject/NetworkObjectSynchronizationTests.cs index 7f58283..695dde8 100644 --- a/Tests/Runtime/NetworkObject/NetworkObjectSynchronizationTests.cs +++ b/Tests/Runtime/NetworkObject/NetworkObjectSynchronizationTests.cs @@ -78,13 +78,13 @@ protected override void OnNewClientCreated(NetworkManager networkManager) { networkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab; networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety = m_VariableLengthSafety == VariableLengthSafety.EnabledNetVarSafety; - foreach (var networkPrefab in m_ServerNetworkManager.NetworkConfig.NetworkPrefabs) + foreach (var networkPrefab in m_ServerNetworkManager.NetworkConfig.Prefabs.Prefabs) { // To simulate a failure, we exclude the m_InValidNetworkPrefab from the connecting // client's side. if (networkPrefab.Prefab.name != m_InValidNetworkPrefab.name) { - networkManager.NetworkConfig.NetworkPrefabs.Add(networkPrefab); + networkManager.NetworkConfig.Prefabs.Add(networkPrefab); } } // Disable forcing the same prefabs to avoid failed connections diff --git a/Tests/Runtime/NetworkPrefabHandlerTests.cs b/Tests/Runtime/NetworkPrefabHandlerTests.cs index 091cddc..ee3359c 100644 --- a/Tests/Runtime/NetworkPrefabHandlerTests.cs +++ b/Tests/Runtime/NetworkPrefabHandlerTests.cs @@ -29,7 +29,7 @@ private GameObject MakeValidNetworkPrefab() } /// - /// Tests the NetwokConfig NetworkPrefabs initialization during NetworkManager's Init method to make sure that + /// Tests the NetwokConfig NetworkPrefabsList initialization during NetworkManager's Init method to make sure that /// it will still initialize but remove the invalid prefabs /// [Test] @@ -37,34 +37,34 @@ public void NetworkConfigInvalidNetworkPrefabTest() { // Add null entry - NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(null); + NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(null); // Add a NetworkPrefab with no prefab - NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab()); + NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab()); // Add a NetworkPrefab override with an invalid hash - NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Hash, SourceHashToOverride = 0 }); + NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Hash, SourceHashToOverride = 0 }); // Add a NetworkPrefab override with a valid hash but an invalid target prefab - NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Hash, SourceHashToOverride = 654321, OverridingTargetPrefab = null }); + NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Hash, SourceHashToOverride = 654321, OverridingTargetPrefab = null }); // Add a NetworkPrefab override with a valid hash to override but an invalid target prefab - NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourceHashToOverride = 654321, OverridingTargetPrefab = null }); + NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourceHashToOverride = 654321, OverridingTargetPrefab = null }); // Add a NetworkPrefab override with an invalid source prefab to override - NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourcePrefabToOverride = null }); + NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourcePrefabToOverride = null }); // Add a NetworkPrefab override with a valid source prefab to override but an invalid target prefab - NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourcePrefabToOverride = MakeValidNetworkPrefab(), OverridingTargetPrefab = null }); + NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourcePrefabToOverride = MakeValidNetworkPrefab(), OverridingTargetPrefab = null }); // Add a valid prefab - NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Prefab = MakeValidNetworkPrefab() }); + NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Prefab = MakeValidNetworkPrefab() }); // Add a NetworkPrefab override with a valid hash and valid target prefab - NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Hash, SourceHashToOverride = 11111111, OverridingTargetPrefab = MakeValidNetworkPrefab() }); + NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Hash, SourceHashToOverride = 11111111, OverridingTargetPrefab = MakeValidNetworkPrefab() }); // Add a NetworkPrefab override with a valid prefab and valid target prefab - NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourcePrefabToOverride = MakeValidNetworkPrefab(), OverridingTargetPrefab = MakeValidNetworkPrefab() }); + NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourcePrefabToOverride = MakeValidNetworkPrefab(), OverridingTargetPrefab = MakeValidNetworkPrefab() }); var exceptionOccurred = false; try @@ -79,7 +79,7 @@ public void NetworkConfigInvalidNetworkPrefabTest() Assert.False(exceptionOccurred); // In the end we should only have 3 valid registered network prefabs - Assert.True(NetworkManagerHelper.NetworkManagerObject.NetworkConfig.NetworkPrefabOverrideLinks.Count == 3); + Assert.True(NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.Count == 3); } private const string k_PrefabObjectName = "NetworkPrefabHandlerTestObject"; diff --git a/Tests/Runtime/NetworkShowHideTests.cs b/Tests/Runtime/NetworkShowHideTests.cs index fe6d763..0124cd4 100644 --- a/Tests/Runtime/NetworkShowHideTests.cs +++ b/Tests/Runtime/NetworkShowHideTests.cs @@ -14,6 +14,8 @@ public class ShowHideObject : NetworkBehaviour public static ulong ClientIdToTarget; public static bool Silent; public static int ValueAfterOwnershipChange = 0; + public static Dictionary ObjectsPerClientId = new Dictionary(); + public static List ClientIdsRpcCalledOn; public static NetworkObject GetNetworkObjectById(ulong networkObjectId) { @@ -44,6 +46,15 @@ public override void OnNetworkSpawn() Debug.Assert(MyListSetOnSpawn[0] == 45); } + if (ObjectsPerClientId.ContainsKey(NetworkManager.LocalClientId)) + { + ObjectsPerClientId[NetworkManager.LocalClientId] = this; + } + else + { + ObjectsPerClientId.Add(NetworkManager.LocalClientId, this); + } + base.OnNetworkSpawn(); } @@ -59,6 +70,7 @@ public override void OnNetworkDespawn() public NetworkVariable MyNetworkVariable; public NetworkList MyListSetOnSpawn; public NetworkVariable MyOwnerReadNetworkVariable; + public NetworkList MyList; static public NetworkManager NetworkManagerOfInterest; internal static int GainOwnershipCount = 0; @@ -70,6 +82,7 @@ private void Awake() MyNetworkVariable.OnValueChanged += Changed; MyListSetOnSpawn = new NetworkList(); + MyList = new NetworkList(); MyOwnerReadNetworkVariable = new NetworkVariable(readPerm: NetworkVariableReadPermission.Owner); MyOwnerReadNetworkVariable.OnValueChanged += OwnerReadChanged; @@ -96,11 +109,26 @@ public void Changed(int before, int after) Debug.Log($"Value changed from {before} to {after}"); } } + + [ClientRpc] + public void SomeRandomClientRPC() + { + Debug.Log($"RPC called {NetworkManager.LocalClientId}"); + if (ClientIdsRpcCalledOn != null) + { + ClientIdsRpcCalledOn.Add(NetworkManager.LocalClientId); + } + } + + public void TriggerRpc() + { + SomeRandomClientRPC(); + } } public class NetworkShowHideTests : NetcodeIntegrationTest { - protected override int NumberOfClients => 2; + protected override int NumberOfClients => 4; private ulong m_ClientId0; private GameObject m_PrefabToSpawn; @@ -124,7 +152,7 @@ private IEnumerator CheckVisible(bool isVisible) int count = 0; do { - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5); + yield return WaitForTicks(m_ServerNetworkManager, 5); count++; if (count > 20) @@ -240,11 +268,11 @@ public IEnumerator NetworkShowHideTest() // hide them on one client Show(mode == 0, false); - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5); + yield return WaitForTicks(m_ServerNetworkManager, 5); m_NetSpawnedObject1.GetComponent().MyNetworkVariable.Value = 3; - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5); + yield return WaitForTicks(m_ServerNetworkManager, 5); // verify they got hidden yield return CheckVisible(false); @@ -286,10 +314,10 @@ public IEnumerator NetworkShowHideQuickTest() Show(mode == 0, false); Show(mode == 0, true); - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5); + yield return WaitForTicks(m_ServerNetworkManager, 5); yield return WaitForConditionOrTimeOut(RefreshNetworkObjects); AssertOnTimeout($"Could not refresh all NetworkObjects!"); - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5); + yield return WaitForTicks(m_ServerNetworkManager, 5); // verify they become visible yield return CheckVisible(true); @@ -315,7 +343,7 @@ public IEnumerator NetworkHideDespawnTest() m_NetSpawnedObject1.NetworkHide(m_ClientId0); m_NetSpawnedObject1.Despawn(); - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5); + yield return WaitForTicks(m_ServerNetworkManager, 5); LogAssert.NoUnexpectedReceived(); } @@ -372,7 +400,7 @@ public IEnumerator NetworkHideChangeOwnershipNotHidden() m_NetSpawnedObject1.GetComponent().MyOwnerReadNetworkVariable.Value++; // wait for three ticks - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 3); + yield return WaitForTicks(m_ServerNetworkManager, 3); // check we'll actually be changing owners Assert.False(ShowHideObject.ClientTargetedNetworkObjects[0].OwnerClientId == m_ClientNetworkManagers[0].LocalClientId); @@ -384,8 +412,8 @@ public IEnumerator NetworkHideChangeOwnershipNotHidden() m_NetSpawnedObject1.ChangeOwnership(m_ClientNetworkManagers[0].LocalClientId); // wait three ticks - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 3); - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ClientNetworkManagers[0], 3); + yield return WaitForTicks(m_ServerNetworkManager, 3); + yield return WaitForTicks(m_ClientNetworkManagers[0], 3); // verify ownership changed Assert.True(ShowHideObject.ClientTargetedNetworkObjects[0].OwnerClientId == m_ClientNetworkManagers[0].LocalClientId); @@ -394,5 +422,155 @@ public IEnumerator NetworkHideChangeOwnershipNotHidden() Assert.True(ShowHideObject.ValueAfterOwnershipChange == 1); } + private string Display(NetworkList list) + { + string message = ""; + foreach (var i in list) + { + message += $"{i}, "; + } + + return message; + } + + private void Compare(NetworkList list1, NetworkList list2) + { + if (list1.Count != list2.Count) + { + string message = $"{Display(list1)} versus {Display(list2)}"; + Debug.Log(message); + } + else + { + for (var i = 0; i < list1.Count; i++) + { + if (list1[i] != list2[i]) + { + string message = $"{Display(list1)} versus {Display(list2)}"; + Debug.Log(message); + break; + } + } + } + + Debug.Assert(list1.Count == list2.Count); + } + + private IEnumerator HideThenShowAndHideThenModifyAndShow() + { + Debug.Log("Hiding"); + // hide + m_NetSpawnedObject1.NetworkHide(1); + yield return WaitForTicks(m_ServerNetworkManager, 3); + yield return WaitForTicks(m_ClientNetworkManagers[0], 3); + + Debug.Log("Showing and Hiding"); + // show and hide + m_NetSpawnedObject1.NetworkShow(1); + m_NetSpawnedObject1.NetworkHide(1); + yield return WaitForTicks(m_ServerNetworkManager, 3); + yield return WaitForTicks(m_ClientNetworkManagers[0], 3); + + Debug.Log("Modifying and Showing"); + // modify and show + m_NetSpawnedObject1.GetComponent().MyList.Add(5); + m_NetSpawnedObject1.NetworkShow(1); + yield return WaitForTicks(m_ServerNetworkManager, 3); + yield return WaitForTicks(m_ClientNetworkManagers[0], 3); + } + + + private IEnumerator HideThenModifyAndShow() + { + // hide + m_NetSpawnedObject1.NetworkHide(1); + yield return WaitForTicks(m_ServerNetworkManager, 3); + + // modify + m_NetSpawnedObject1.GetComponent().MyList.Add(5); + // show + m_NetSpawnedObject1.NetworkShow(1); + yield return WaitForTicks(m_ServerNetworkManager, 3); + yield return WaitForTicks(m_ClientNetworkManagers[0], 3); + + } + + private IEnumerator HideThenShowAndModify() + { + // hide + m_NetSpawnedObject1.NetworkHide(1); + yield return WaitForTicks(m_ServerNetworkManager, 3); + + // show + m_NetSpawnedObject1.NetworkShow(1); + // modify + m_NetSpawnedObject1.GetComponent().MyList.Add(5); + yield return WaitForTicks(m_ServerNetworkManager, 3); + yield return WaitForTicks(m_ClientNetworkManagers[0], 3); + } + + private IEnumerator HideThenShowAndRPC() + { + // hide + m_NetSpawnedObject1.NetworkHide(1); + yield return WaitForTicks(m_ServerNetworkManager, 3); + + // show + m_NetSpawnedObject1.NetworkShow(1); + m_NetSpawnedObject1.GetComponent().TriggerRpc(); + yield return WaitForTicks(m_ServerNetworkManager, 3); + } + + [UnityTest] + public IEnumerator NetworkShowHideAroundListModify() + { + ShowHideObject.ClientTargetedNetworkObjects.Clear(); + ShowHideObject.ClientIdToTarget = m_ClientNetworkManagers[1].LocalClientId; + ShowHideObject.Silent = true; + + var spawnedObject1 = SpawnObject(m_PrefabToSpawn, m_ServerNetworkManager); + m_NetSpawnedObject1 = spawnedObject1.GetComponent(); + + // wait for host to have spawned and gained ownership + while (ShowHideObject.GainOwnershipCount == 0) + { + yield return new WaitForSeconds(0.0f); + } + + for (int i = 0; i < 4; i++) + { + // wait for three ticks + yield return WaitForTicks(m_ServerNetworkManager, 3); + yield return WaitForTicks(m_ClientNetworkManagers[0], 3); + + switch (i) + { + case 0: + Debug.Log("Running HideThenModifyAndShow"); + yield return HideThenModifyAndShow(); + break; + case 1: + Debug.Log("Running HideThenShowAndModify"); + yield return HideThenShowAndModify(); + break; + case 2: + Debug.Log("Running HideThenShowAndHideThenModifyAndShow"); + yield return HideThenShowAndHideThenModifyAndShow(); + break; + case 3: + Debug.Log("Running HideThenShowAndRPC"); + ShowHideObject.ClientIdsRpcCalledOn = new List(); + yield return HideThenShowAndRPC(); + // Provide enough time for slower systems or VM systems possibly under a heavy load could fail on this test + yield return WaitForConditionOrTimeOut(() => ShowHideObject.ClientIdsRpcCalledOn.Count == NumberOfClients + 1); + AssertOnTimeout($"Timed out waiting for ClientIdsRpcCalledOn.Count ({ShowHideObject.ClientIdsRpcCalledOn.Count}) to equal ({NumberOfClients + 1})!"); + break; + + } + + Compare(ShowHideObject.ObjectsPerClientId[0].MyList, ShowHideObject.ObjectsPerClientId[1].MyList); + Compare(ShowHideObject.ObjectsPerClientId[0].MyList, ShowHideObject.ObjectsPerClientId[2].MyList); + } + } } } diff --git a/Tests/Runtime/NetworkTransform/NetworkTransformTests.cs b/Tests/Runtime/NetworkTransform/NetworkTransformTests.cs index f3af7bd..558bd48 100644 --- a/Tests/Runtime/NetworkTransform/NetworkTransformTests.cs +++ b/Tests/Runtime/NetworkTransform/NetworkTransformTests.cs @@ -402,7 +402,7 @@ private IEnumerator WaitForNextTick() protected override void OnNewClientCreated(NetworkManager networkManager) { - networkManager.NetworkConfig.NetworkPrefabs = m_ServerNetworkManager.NetworkConfig.NetworkPrefabs; + networkManager.NetworkConfig.Prefabs = m_ServerNetworkManager.NetworkConfig.Prefabs; base.OnNewClientCreated(networkManager); } diff --git a/Tests/Runtime/NetworkVariableTests.cs b/Tests/Runtime/NetworkVariableTests.cs index d4f17b2..dfc7a0f 100644 --- a/Tests/Runtime/NetworkVariableTests.cs +++ b/Tests/Runtime/NetworkVariableTests.cs @@ -236,7 +236,7 @@ public IEnumerator ClientChangesOwnerWritableNetVar() int clientManagerIndex = m_ClientNetworkManagers.Length - 1; var newOwnerClientId = m_ClientNetworkManagers[clientManagerIndex].LocalClientId; testObjServer.ChangeOwnership(newOwnerClientId); - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 2); + yield return WaitForTicks(m_ServerNetworkManager, 2); yield return WaitForOwnerWritableAreEqualOnAll(); @@ -269,7 +269,7 @@ public IEnumerator ClientOwnerWithReadWriteChangesNetVar() int clientManagerIndex = m_ClientNetworkManagers.Length - 1; var newOwnerClientId = m_ClientNetworkManagers[clientManagerIndex].LocalClientId; testObjServer.ChangeOwnership(newOwnerClientId); - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 2); + yield return WaitForTicks(m_ServerNetworkManager, 2); yield return WaitForOwnerWritableAreEqualOnAll(); @@ -301,7 +301,7 @@ public IEnumerator ClientCannotChangeServerWritableNetVar() int clientManagerIndex = m_ClientNetworkManagers.Length - 1; var newOwnerClientId = m_ClientNetworkManagers[clientManagerIndex].LocalClientId; testObjServer.ChangeOwnership(newOwnerClientId); - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 2); + yield return WaitForTicks(m_ServerNetworkManager, 2); yield return WaitForServerWritableAreEqualOnAll(); @@ -333,7 +333,7 @@ public IEnumerator ServerCannotChangeOwnerWritableNetVar() int clientManagerIndex = m_ClientNetworkManagers.Length - 1; var newOwnerClientId = m_ClientNetworkManagers[clientManagerIndex].LocalClientId; testObjServer.ChangeOwnership(newOwnerClientId); - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 2); + yield return WaitForTicks(m_ServerNetworkManager, 2); yield return WaitForOwnerWritableAreEqualOnAll(); diff --git a/Tests/Runtime/OwnerModifiedTests.cs b/Tests/Runtime/OwnerModifiedTests.cs index 52ddb2b..41296c1 100644 --- a/Tests/Runtime/OwnerModifiedTests.cs +++ b/Tests/Runtime/OwnerModifiedTests.cs @@ -91,10 +91,10 @@ public IEnumerator OwnerModifiedTest() ownerModLastClient.NetworkUpdateStageToCheck = (NetworkUpdateStage)updateLoopType; Debug.Log($"Testing Update Stage: {ownerModLastClient.NetworkUpdateStageToCheck}"); ownerModLastClient.AddValues = true; - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5); + yield return WaitForTicks(m_ServerNetworkManager, 5); } - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5); + yield return WaitForTicks(m_ServerNetworkManager, 5); // We'll have at least one update per stage per client, if all goes well. Assert.True(OwnerModifiedObject.Updates > 20); diff --git a/Tests/Runtime/OwnerPermissionTests.cs b/Tests/Runtime/OwnerPermissionTests.cs index abe4355..c0d7dd7 100644 --- a/Tests/Runtime/OwnerPermissionTests.cs +++ b/Tests/Runtime/OwnerPermissionTests.cs @@ -197,9 +197,9 @@ public IEnumerator OwnerPermissionTest() // Verify client-owned networkList can only be written by owner Debug.Assert(gotException == (clientWriting != objectIndex)); - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5); - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ClientNetworkManagers[0], 5); - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ClientNetworkManagers[1], 5); + yield return WaitForTicks(m_ServerNetworkManager, 5); + yield return WaitForTicks(m_ClientNetworkManagers[0], 5); + yield return WaitForTicks(m_ClientNetworkManagers[1], 5); OwnerPermissionObject.VerifyConsistency(); } diff --git a/Tests/Runtime/Physics/NetworkRigidbody2DTest.cs b/Tests/Runtime/Physics/NetworkRigidbody2DTest.cs index 7f98b62..f92cab9 100644 --- a/Tests/Runtime/Physics/NetworkRigidbody2DTest.cs +++ b/Tests/Runtime/Physics/NetworkRigidbody2DTest.cs @@ -53,7 +53,7 @@ public IEnumerator TestRigidbodyKinematicEnableDisable() Assert.IsNotNull(serverPlayer); Assert.IsNotNull(clientPlayer); - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5); + yield return WaitForTicks(m_ServerNetworkManager, 5); // server rigidbody has authority and should have a kinematic mode of false Assert.True(serverPlayer.GetComponent().isKinematic == Kinematic); @@ -66,12 +66,12 @@ public IEnumerator TestRigidbodyKinematicEnableDisable() // despawn the server player, (but keep it around on the server) serverPlayer.GetComponent().Despawn(false); - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5); + yield return WaitForTicks(m_ServerNetworkManager, 5); // This should equal Kinematic Assert.IsTrue(serverPlayer.GetComponent().isKinematic == Kinematic); - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 5); + yield return WaitForTicks(m_ServerNetworkManager, 5); Assert.IsTrue(clientPlayer == null); // safety check that object is actually despawned. } diff --git a/Tests/Runtime/Physics/NetworkRigidbodyTest.cs b/Tests/Runtime/Physics/NetworkRigidbodyTest.cs index 910a096..31078d8 100644 --- a/Tests/Runtime/Physics/NetworkRigidbodyTest.cs +++ b/Tests/Runtime/Physics/NetworkRigidbodyTest.cs @@ -40,7 +40,7 @@ public IEnumerator TestRigidbodyKinematicEnableDisable() Assert.IsNotNull(serverPlayer, "serverPlayer is not null"); Assert.IsNotNull(clientPlayer, "clientPlayer is not null"); - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 3); + yield return WaitForTicks(m_ServerNetworkManager, 3); // server rigidbody has authority and should not be kinematic Assert.True(serverPlayer.GetComponent().isKinematic == false, "serverPlayer kinematic"); @@ -53,12 +53,12 @@ public IEnumerator TestRigidbodyKinematicEnableDisable() // despawn the server player (but keep it around on the server) serverPlayer.GetComponent().Despawn(false); - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 3); + yield return WaitForTicks(m_ServerNetworkManager, 3); // When despawned, we should always be kinematic (i.e. don't apply physics when despawned) Assert.IsTrue(serverPlayer.GetComponent().isKinematic == true, "serverPlayer second kinematic"); - yield return NetcodeIntegrationTestHelpers.WaitForTicks(m_ServerNetworkManager, 3); + yield return WaitForTicks(m_ServerNetworkManager, 3); Assert.IsTrue(clientPlayer == null, "clientPlayer being null"); // safety check that object is actually despawned. } diff --git a/Tests/Runtime/RpcManyClientsTests.cs b/Tests/Runtime/RpcManyClientsTests.cs index 89dfbe9..2b6e50a 100644 --- a/Tests/Runtime/RpcManyClientsTests.cs +++ b/Tests/Runtime/RpcManyClientsTests.cs @@ -62,10 +62,10 @@ public GameObject PreparePrefab(Type type) prefabToSpawn.AddComponent(type); var networkObjectPrefab = prefabToSpawn.AddComponent(); NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(networkObjectPrefab); - m_ServerNetworkManager.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Prefab = prefabToSpawn }); + m_ServerNetworkManager.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Prefab = prefabToSpawn }); foreach (var clientNetworkManager in m_ClientNetworkManagers) { - clientNetworkManager.NetworkConfig.NetworkPrefabs.Add(new NetworkPrefab() { Prefab = prefabToSpawn }); + clientNetworkManager.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Prefab = prefabToSpawn }); } return prefabToSpawn; } diff --git a/package.json b/package.json index 82dbcdf..8c35058 100644 --- a/package.json +++ b/package.json @@ -2,20 +2,23 @@ "name": "com.unity.netcode.gameobjects", "displayName": "Netcode for GameObjects", "description": "Netcode for GameObjects is a high-level netcode SDK that provides networking capabilities to GameObject/MonoBehaviour workflows within Unity and sits on top of underlying transport layer.", - "version": "1.2.0", + "version": "1.3.1", "unity": "2020.3", "dependencies": { "com.unity.nuget.mono-cecil": "1.10.1", - "com.unity.transport": "1.3.0" + "com.unity.transport": "1.3.3" + }, + "_upm": { + "changelog": "### Added\n\n- Added detection and graceful handling of corrupt packets for additional safety. (#2419)\n\n### Changed\n\n- The UTP component UI has been updated to be more user-friendly for new users by adding a simple toggle to switch between local-only (127.0.0.1) and remote (0.0.0.0) binding modes, using the toggle \"Allow Remote Connections\" (#2408)\n- Updated `UnityTransport` dependency on `com.unity.transport` to 1.3.3. (#2450)\n- `NetworkShow()` of `NetworkObject`s are delayed until the end of the frame to ensure consistency of delta-driven variables like `NetworkList`.\n- Dirty `NetworkObject` are reset at end-of-frame and not at serialization time.\n- `NetworkHide()` of an object that was just `NetworkShow()`n produces a warning, as remote clients will _not_ get a spawn/despawn pair.\n- Renamed the NetworkTransform.SetState parameter `shouldGhostsInterpolate` to `teleportDisabled` for better clarity of what that parameter does. (#2228)\n- Network prefabs are now stored in a ScriptableObject that can be shared between NetworkManagers, and have been exposed for public access. By default, a Default Prefabs List is created that contains all NetworkObject prefabs in the project, and new NetworkManagers will default to using that unless that option is turned off in the Netcode for GameObjects settings. Existing NetworkManagers will maintain their existing lists, which can be migrated to the new format via a button in their inspector. (#2322)\n\n### Fixed\n\n- Fixed issue where changes to a layer's weight would not synchronize unless a state transition was occurring.(#2399)\n- Fixed issue where `NetworkManager.LocalClientId` was returning the `NetworkTransport.ServerClientId` as opposed to the `NetworkManager.m_LocalClientId`. (#2398)\n- Fixed issue where a dynamically spawned `NetworkObject` parented under an in-scene placed `NetworkObject` would have its `InScenePlaced` value changed to `true`. This would result in a soft synchronization error for late joining clients. (#2396)\n- Fixed a UTP test that was failing when you install Unity Transport package 2.0.0 or newer. (#2347)\n- Fixed issue where `NetcodeSettingsProvider` would throw an exception in Unity 2020.3.x versions. (#2345)\n- Fixed server side issue where, depending upon component ordering, some NetworkBehaviour components might not have their OnNetworkDespawn method invoked if the client side disconnected. (#2323)\n- Fixed a case where data corruption could occur when using UnityTransport when reaching a certain level of send throughput. (#2332)\n- Fixed an issue in `UnityTransport` where an exception would be thrown if starting a Relay host/server on WebGL. This exception should only be thrown if using direct connections (where WebGL can't act as a host/server). (#2321)\n- Fixed `NetworkAnimator` issue where it was not checking for `AnimatorStateTtansition.destinationStateMachine` and any possible sub-states defined within it. (#2309)\n- Fixed `NetworkAnimator` issue where the host client was receiving the ClientRpc animation updates when the host was the owner.(#2309)\n- Fixed `NetworkAnimator` issue with using pooled objects and when specific properties are cleaned during despawn and destroy.(#2309)\n- Fixed issue where `NetworkAnimator` was checking for animation changes when the associated `NetworkObject` was not spawned.(#2309)\n- Corrected an issue with the documentation for BufferSerializer (#2401)" }, "upmCi": { - "footprint": "4160b9a4b03a930793225fd4767f2b00fee62c79" + "footprint": "edebf4ce36d2ecd3e2a7632dbf88da8cbc89aa50" }, - "documentationUrl": "https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@1.2/manual/index.html", + "documentationUrl": "https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@1.3/manual/index.html", "repository": { "url": "https://github.com/Unity-Technologies/com.unity.netcode.gameobjects.git", "type": "git", - "revision": "789f0930ead8e5ba27e123323f407d6f3393aa7b" + "revision": "469b46fabe1a78032a31ab04a15490a6912dadfb" }, "samples": [ {