: INetworkPrefabIn
## Register a prefab handler
-Once you've [created a prefab handler](#create-a-prefab-handler), whether by implementing or deriving, you need to register any new instance of that handler with the network prefab handler system using `NetworkManager.PrefabHandler.AddHandler`. Prefab handlers are registered against a NetworkObject's [GlobalObjectIdHash](../basics/networkobject.md#using-networkobjects).
+Once you've [created a prefab handler](#create-a-prefab-handler), whether by implementing or deriving, you need to register any new instance of that handler with the network prefab handler system using `NetworkManager.PrefabHandler.AddHandler`. Prefab handlers are registered against a NetworkObject's [GlobalObjectIdHash](../components/core/networkobject.md#using-networkobjects).
```csharp
public class GameManager : NetworkBehaviour
@@ -70,7 +70,7 @@ public class GameManager : NetworkBehaviour
}
```
-To un-register a prefab handler, you can [invoke the `NetworkManager.PrefabHandler.RemoveHandler` method](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkPrefabHandler.html#Unity_Netcode_NetworkPrefabHandler_RemoveHandler_System_UInt32_). There are several override versions of this method.
+To un-register a prefab handler, you can [invoke the `NetworkManager.PrefabHandler.RemoveHandler` method](xref:Unity.Netcode.NetworkPrefabHandler.RemoveHandler*). There are several override versions of this method.
## Object spawning with prefab handlers
diff --git a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/network-update-loop-system/network-update-loop-reference.md b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/network-update-loop-system/network-update-loop-reference.md
index fd013937a4..72ec0db77c 100644
--- a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/network-update-loop-system/network-update-loop-reference.md
+++ b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/network-update-loop-system/network-update-loop-reference.md
@@ -6,7 +6,7 @@ The following diagrams provide insight into the Network Update Loop process and
-
+
@@ -14,6 +14,6 @@ The following diagrams provide insight into the Network Update Loop process and
-
+
diff --git a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/networkobject-parenting.md b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/networkobject-parenting.md
index 435edf39a5..a2c6c755ea 100644
--- a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/networkobject-parenting.md
+++ b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/networkobject-parenting.md
@@ -26,7 +26,7 @@ If you aren't familiar with transform parenting in Unity, then it's recommended
### OnNetworkObjectParentChanged
-[`NetworkBehaviour.OnNetworkObjectParentChanged`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkBehaviour.html#Unity_Netcode_NetworkBehaviour_OnNetworkObjectParentChanged_Unity_Netcode_NetworkObject_) is a virtual method you can override to be notified when a NetworkObject component's parent has changed. The [`MonoBehaviour.OnTransformParentChanged()`](https://docs.unity3d.com/ScriptReference/MonoBehaviour.OnTransformParentChanged.html) method is used by NetworkObject component to catch `transform.parent` changes and notify its associated NetworkBehaviour components.
+[`NetworkBehaviour.OnNetworkObjectParentChanged`](xref:Unity.Netcode.NetworkBehaviour.OnNetworkObjectParentChanged*) is a virtual method you can override to be notified when a NetworkObject component's parent has changed. The [`MonoBehaviour.OnTransformParentChanged()`](https://docs.unity3d.com/ScriptReference/MonoBehaviour.OnTransformParentChanged.html) method is used by NetworkObject component to catch `transform.parent` changes and notify its associated NetworkBehaviour components.
```csharp
///
@@ -49,7 +49,7 @@ The [owner](../terms-concepts/ownership.md) of a NetworkObject can always parent
By default, only the [authority](../terms-concepts/authority.md) of a NetworkObject can parent a NetworkObject under a non-networked object. This means in a client-server game, only the server (or host) can control NetworkObject component parenting. In a distributed authority game the [owner](../terms-concepts/ownership.md) of the object can always parent the object.
-To allow the [owner](../terms-concepts/ownership.md) to parent their owned NetworkObject in a client-server game, use the [`NetworkObject.AllowOwnerToParent`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkObject.html#Unity_Netcode_NetworkObject_AllowOwnerToParent) property.
+To allow the [owner](../terms-concepts/ownership.md) to parent their owned NetworkObject in a client-server game, use the [`NetworkObject.AllowOwnerToParent`](xref:Unity.Netcode.NetworkObject.AllowOwnerToParent) property.
@@ -78,7 +78,7 @@ If you plan on parenting in-scene placed NetworkObject components with a player
For more information, refer to:
- [Real World In-scene NetworkObject Parenting of Players Solution](inscene_parenting_player.md)
-- [Scene Event Notifications](../basics/scenemanagement/scene-events#scene-event-notifications)
+- [Scene Event Notifications](../basics/scenemanagement/scene-events.md#scene-event-notifications)
- [In-Scene NetworkObjects](../basics/scenemanagement/inscene-placed-networkobjects.md)
### WorldPositionStays usage
diff --git a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/networktime-ticks.md b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/networktime-ticks.md
index 1742f87805..500b3d4b7c 100644
--- a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/networktime-ticks.md
+++ b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/networktime-ticks.md
@@ -183,6 +183,6 @@ For games with short play sessions casting the time to float is safe or `TimeAsF
> [!NOTE]
> The properties of the `NetworkTimeSystem` should be left untouched on the server/host. Changing the values on the client is sufficient to change the behavior of the time system.
-The way network time gets calculated can be configured in the `NetworkTimeSystem` if needed. Refer to the [API docs](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkTimeSystem.html) for information about the properties which can be modified. All properties can be safely adjusted at runtime. For instance, buffer values can be increased for a player with a bad connection.
+The way network time gets calculated can be configured in the `NetworkTimeSystem` if needed. Refer to the [API docs](xref:Unity.Netcode.NetworkTimeSystem) for information about the properties which can be modified. All properties can be safely adjusted at runtime. For instance, buffer values can be increased for a player with a bad connection.
diff --git a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/physics.md b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/physics.md
index 8a309cca24..134a78cb43 100644
--- a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/physics.md
+++ b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/physics.md
@@ -34,7 +34,7 @@ Since PhysX has no concept of local space, it can be difficult to synchronize tw
## Using AttachableBehaviour or Joint
-The implementation of physics in a networked project differs from a single player project. This is especially true when you're using NetworkTransform and NetworkRigidbody components with [`NetworkRigidbody.UseRigidBodyForMotion`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.Components.NetworkRigidbodyBase.html#Unity_Netcode_Components_NetworkRigidbodyBase_UseRigidBodyForMotion) enabled. Deciding whether to use a Joint or an AttachableBehaviour component depends on your project's requirements.
+The implementation of physics in a networked project differs from a single player project. This is especially true when you're using NetworkTransform and NetworkRigidbody components with [`NetworkRigidbody.UseRigidBodyForMotion`](xref:Unity.Netcode.Components.NetworkRigidbodyBase.UseRigidBodyForMotion) enabled. Deciding whether to use a Joint or an AttachableBehaviour component depends on your project's requirements.
For example, if you want to create world items that players can pick up, you may have the following requirements:
diff --git a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/inetworkserializable.md b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/inetworkserializable.md
index 36d83416ba..ab60e161c6 100644
--- a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/inetworkserializable.md
+++ b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/inetworkserializable.md
@@ -1,9 +1,14 @@
-# INetworkSerializable
+# Customize serializable types with INetworkSerializable
-You can use the `INetworkSerializable` interface to define custom serializable types.
+> [!NOTE]
+> Read the [Serialization overview](./serialization-overview.md) page to understand the basics of serialization before customizing serializable types with `INetworkSerializable`.
+
+You can use the `INetworkSerializable` interface to define custom serializable types. This interface has one function: `NetworkSerialize(BufferSerializer serializer)`, which ingests a bi-directional [`BufferSerializer`](../bufferserializer.md) that you can use to implement bi-directional custom serialization.
+
+`INetworkSerializable` can be implemented on both managed and unmanaged types, although serializing managed types isn't recommended because it can reduce your game's performance.
```csharp
-struct MyComplexStruct : INetworkSerializable
+struct SpawnPoint : INetworkSerializable
{
public Vector3 Position;
public Quaternion Rotation;
@@ -18,24 +23,20 @@ struct MyComplexStruct : INetworkSerializable
}
```
-Types implementing `INetworkSerializable` are supported by `NetworkSerializer`, `RPC` s and `NetworkVariable` s.
+Types implementing `INetworkSerializable` are supported by [`FastBufferReader` and `FastBufferWriter`](../fastbufferwriter-fastbufferreader.md), [`RPC`s'](../message-system/rpc.md), and [`NetworkVariable`s](../../basics/networkvariable.md).
```csharp
-
[Rpc(SendTo.Server)]
-void MyServerRpc(MyComplexStruct myStruct) { /* ... */ }
+void SpawnAtPointRpc(SpawnPoint spawnPoint) { /* ... */ }
-void Update()
+void DoSpawnHere()
{
- if (Input.GetKeyDown(KeyCode.P))
+ var spawnPoint = new SpawnPoint
{
- MyServerRpc(
- new MyComplexStruct
- {
- Position = transform.position,
- Rotation = transform.rotation
- }); // Client -> Server
- }
+ Position = transform.position,
+ Rotation = transform.rotation
+ };
+ SpawnAtPointRpc(spawnPoint); // Client -> Server
}
```
@@ -59,7 +60,7 @@ The following example explores a more advanced use case.
```csharp
-public struct MyMoveStruct : INetworkSerializable
+public struct SpawnWithMovement : INetworkSerializable
{
public Vector3 Position;
public Quaternion Rotation;
@@ -125,7 +126,7 @@ Review the following example:
```csharp
-public struct MyStructA : INetworkSerializable
+public struct SpawnPoint : INetworkSerializable
{
public Vector3 Position;
public Quaternion Rotation;
@@ -137,17 +138,17 @@ public struct MyStructA : INetworkSerializable
}
}
-public struct MyStructB : INetworkSerializable
+public struct SpawnInfo : INetworkSerializable
{
public int SomeNumber;
public string SomeText;
- public MyStructA StructA;
+ public SpawnPoint SpawnPoint;
void NetworkSerialize(BufferSerializer serializer) where T : IReaderWriter
{
serializer.SerializeValue(ref SomeNumber);
serializer.SerializeValue(ref SomeText);
- StructA.NetworkSerialize(serializer);
+ SpawnPoint.NetworkSerialize(serializer);
}
}
```
@@ -167,7 +168,7 @@ While you can have nested `INetworkSerializable` implementations (an `INetworkSe
```csharp
/// This isn't supported.
-public struct MyStructB : MyStructA
+public struct SpawnInfo : SpawnPoint
{
public int SomeNumber;
public string SomeText;
@@ -232,4 +233,4 @@ Then declare this network variable like so:
```csharp
NetworkVariable myVar = new NetworkVariable();
-```
\ No newline at end of file
+```
diff --git a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/inetworkserializebymemcpy.md b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/inetworkserializebymemcpy.md
index 7a684dbaba..b79df9ff27 100644
--- a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/inetworkserializebymemcpy.md
+++ b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/inetworkserializebymemcpy.md
@@ -1,4 +1,7 @@
-# INetworkSerializeByMemcpy
+# Serialize unmanaged structs with INetworkSerializeByMemcpy
+
+> [!NOTE]
+> Read the [Serialization overview](./serialization-overview.md) page to understand the basics of serialization before using `INetworkSerializeByMemcpy` to serialize unmanaged structs.
The `INetworkSerializeByMemcpy` interface is used to mark an unmanaged struct type as being trivially serializable over the network by directly copying the whole struct, byte-for-byte, as it appears in memory, into and out of the buffer. This can offer some benefits for performance compared to serializing one field at a time, especially if the struct has many fields in it, but it may be less efficient from a bandwidth-usage perspective, as fields will often be padded for memory alignment and you won't be able to "pack" any of the fields to optimize for space usage.
@@ -14,7 +17,7 @@ public struct MyStruct : INetworkSerializeByMemcpy
}
```
-If you have a type you wish to serialize that you know is compatible with this method of serialization, but don't have access to modify the struct to add this interface, you can wrap your values in `ForceNetworkSerializeByMemcpy` to enable it to be serialized this way. This works in both `RPC`s and `NetworkVariables`, as well as in other contexts such as `BufferSerializer<>`, `FastBufferReader`, and `FastBufferWriter`.
+If you have a type you wish to serialize that you know is compatible with this method of serialization, but don't have access to modify the struct to add this interface, you can wrap your values in `ForceNetworkSerializeByMemcpy` to enable it to be serialized this way. This works in both [`RPC`s](../message-system/rpc.md) and [`NetworkVariable`s](../../basics/networkvariable.md), as well as in other contexts such as with [`BufferSerializer<>`](../bufferserializer.md) or [`FastBufferReader`, and `FastBufferWriter`](../fastbufferwriter-fastbufferreader.md).
```csharp
public NetworkVariable> GuidVar;
diff --git a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/networkobject-serialization.md b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/networkobject-serialization.md
index 9ca778028d..d3800a7b09 100644
--- a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/networkobject-serialization.md
+++ b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/networkobject-serialization.md
@@ -1,14 +1,18 @@
-# NetworkObject and NetworkBehaviour
+# NetworkObject and NetworkBehaviour serialization
-`GameObjects`, `NetworkObjects` and NetworkBehaviour aren't serializable types so they can't be used in `RPCs` or `NetworkVariables` by default.
+> [!NOTE]
+> Read the [Serialization overview](./serialization-overview.md) page to understand the basics of serialization before learning how to serialize `NetworkObjects` and `NetworkBehaviours`.
+
+`GameObject`, [`NetworkObject`](../../components/core/networkobject.md) and [`NetworkBehaviour`](../../components/core/networkbehaviour.md) aren't serializable types so they can't be used in [`RPC`s](../message-system/rpc.md) or [`NetworkVariable`s](../../basics/networkvariable.md) by default.
-There are two convenience wrappers which can be used to send a reference to a NetworkObject or a NetworkBehaviour over RPCs or `NetworkVariables`.
+There are two convenience wrappers which can be used to send a reference to a `NetworkObject` or a `NetworkBehaviour` over an `RPC` or in a `NetworkVariable`.
## NetworkObjectReference
-`NetworkObjectReference` can be used to serialize a reference to a NetworkObject. It can only be used on already spawned `NetworkObjects`.
+`NetworkObjectReference` can be used to serialize a reference to a `NetworkObject`. It can only be used on already spawned `NetworkObject`s.
Here is an example of using NetworkObject reference to send a target NetworkObject over an RPC:
+
```csharp
public class Weapon : NetworkBehaviour
{
@@ -36,6 +40,7 @@ public class Weapon : NetworkBehaviour
### Implicit Operators
There are also implicit operators which convert from/to `NetworkObject/GameObject` which can be used to simplify code. For instance the above example can also be written in the following way:
+
```csharp
public class Weapon : NetworkBehaviour
{
@@ -51,6 +56,7 @@ public class Weapon : NetworkBehaviour
}
}
```
+
> [!NOTE]
> The implicit conversion to NetworkObject / GameObject will result in `Null` if the reference can't be found.
@@ -85,6 +91,6 @@ public class Weapon : NetworkBehaviour
## How NetworkObjectReference & NetworkBehaviourReference work
-`NetworkObjectReference` and `NetworkBehaviourReference` are convenience wrappers which serialize the id of a NetworkObject when being sent and on the receiving end retrieve the corresponding ` ` with that id. `NetworkBehaviourReference` sends an additional index which is used to find the right NetworkBehaviour on the NetworkObject.
+`NetworkObjectReference` and `NetworkBehaviourReference` are convenience wrappers which serialize the id of a `NetworkObject` when being sent and on the receiving end retrieve the corresponding `NetworkObject` with that id. `NetworkBehaviourReference` sends an additional index which is used to find the right `NetworkBehaviour` on the `NetworkObject`.
-Both of them are structs implementing the `INetworkSerializable` interface.
+Both of them are structs implementing the [`INetworkSerializable`](./inetworkserializable.md) interface.
diff --git a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/serialization-arrays.md b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/serialization-arrays.md
index c347f4c13e..3ecc26cb99 100644
--- a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/serialization-arrays.md
+++ b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/serialization-arrays.md
@@ -1,6 +1,9 @@
# Arrays and native containers
-Netcode for GameObjects has built-in serialization code for arrays of [C# value-type primitives](cprimitives.md), like `int[]`, and [Unity primitive types](unity-primitives.md). Any arrays of types that aren't handled by the built-in serialization code, such as `string[]`, need to be handled using a container class or structure that implements the [`INetworkSerializable`](inetworkserializable.md) interface.
+> [!NOTE]
+> Read the [Serialization overview](./serialization-overview.md) page to understand the basics of serialization before learning how to serialize arrays and native containers.
+
+Netcode for GameObjects has built-in serialization code for arrays of [C# value-type primitives](cprimitives.md), like `int[]`, and [Unity primitive types](unity-primitives.md). Any arrays of types that aren't handled by the built-in serialization code, such as custom types, need to be handled using a container class or structure that implements the [`INetworkSerializable`](inetworkserializable.md) interface.
## Performance considerations
@@ -17,37 +20,6 @@ Using built-in primitive types is fairly straightforward:
void HelloServerRpc(int[] scores, Color[] colors) { /* ... */ }
```
-## INetworkSerializable implementation example
-
-There are many ways to handle sending an array of managed types. The following example is a simple `string` container class that implements `INetworkSerializable` and can be used as an array of "StringContainers":
-
-```csharp
-[Rpc(SendTo.ClientsAndHost)]
-void SendMessagesClientRpc(StringContainer[] messages)
-{
- foreach (var stringContainer in stringContainers)
- {
- Debug.Log($"{stringContainer.SomeText}");
- }
-}
-
-public class StringContainer : INetworkSerializable
-{
- public string SomeText;
- public void NetworkSerialize(BufferSerializer serializer) where T : IReaderWriter
- {
- if (serializer.IsWriter)
- {
- serializer.GetFastBufferWriter().WriteValueSafe(SomeText);
- }
- else
- {
- serializer.GetFastBufferReader().ReadValueSafe(out SomeText);
- }
- }
-}
-```
-
## Native containers
Netcode for GameObjects supports `NativeArray` and `NativeList` native containers with built-in serialization, RPCs, and NetworkVariables. However, you can't nest either of these containers without causing a crash.
@@ -77,3 +49,7 @@ To serialize a `NativeList` container, you must:
> [!NOTE]
> When using `NativeLists` within `INetworkSerializable`, the list `ref` value must be a valid, initialized `NativeList`.
> NetworkVariables are similar that the value must be initialized before it can receive updates. For example, `public NetworkVariable> ByteListVar = new NetworkVariable>{Value = new NativeList(Allocator.Persistent)};`. RPCs do this automatically.
+
+## Generic collections
+
+For performance reasons, Netcode for GameObjects does not have built-in serialization code for C# generic collections. However, `NetworkVariable` does support [synchronizing generic collection types](../../basics/networkvariable.md#using-collections-with-networkvariables).
diff --git a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/serialization-overview.md b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/serialization-overview.md
new file mode 100644
index 0000000000..ad7fcd4d21
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/serialization/serialization-overview.md
@@ -0,0 +1,36 @@
+# Serialization overview
+
+Netcode for GameObjects uses a default serialization pipeline when using [`RPC`](../../rpc-landing.md)'s, [`NetworkVariable`](../../networkvariables-landing.md)s, or any other Netcode-related tasks that require serialization. The serialization pipeline looks like this:
+
+``
+Custom types => Built-in types => INetworkSerializable
+``
+
+When Netcode for GameObjects first receives a type, it checks for any custom types that you have registered for serialization, then it checks if it's a built-in type, such as a Vector3 or a float. These are handled by default. Otherwise, it checks if the type inherits [`INetworkSerializable`](inetworkserializable.md), and if it does, it calls its write methods.
+
+By default, any type that satisfies the unmanaged generic constraint can be automatically serialized as RPC parameters. This includes all basic types (bool, byte, int, float, enum, for example), as well as any structs that contain only these basic types.
+
+Serialization and deserialization is done via the structs [`FastBufferWriter` and `FastBufferReader`](../fastbufferwriter-fastbufferreader.md). These have methods for serializing individual types and methods for serializing packed numbers, but in particular provide a high-performance method called `WriteValue()/ReadValue()` (for Writers and Readers, respectively) that can extremely quickly write an entire unmanaged struct to a buffer.
+
+`FastBufferWriter` and `FastBufferReader` also contain the functions `FastBufferWriter.WriteNetworkSerializable()` and `FastBufferReader.ReadNetworkSerializable` for writing and reading values that use the `INetworkSerializable` interface.
+
+## Built-in serialization
+
+* [C# primitives](./cprimitives.md)
+* [Unity primitives](./unity-primitives.md)
+* [Enum types](./enum-types.md)
+* [Arrays](./serialization-arrays.md)
+* [Collections](../../basics/networkvariable.md#using-collections-with-networkvariables)
+
+## Custom serialization
+
+* [INetworkSerializable](./inetworkserializable.md)
+* [INetworkSerializeByMemcpy](./inetworkserializebymemcpy.md)
+* [Customizing serialization](../custom-serialization.md)
+* [Custom NetworkVariable implementations](../../basics/custom-networkvariables.md)
+
+## Additional resources
+
+* [NetworkObject serialization](./networkobject-serialization.md)
+* [FastBufferWriter and FastBufferReader](../fastbufferwriter-fastbufferreader.md)
+* [BufferSerializer](../bufferserializer.md)
diff --git a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/session-management.md b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/session-management.md
index 1f80a08d1a..614d2ce32b 100644
--- a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/session-management.md
+++ b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/session-management.md
@@ -19,7 +19,7 @@ You can also decide to clear all data when a session completes or add a timeout
# Reconnection
-The best way to reconnect players depends on your game. For example, if you use a [Player Object](../components/core/networkobject.md#player-objects), a new `Default Player Prefab` automatically spawns when a player connects to the game (including when they reconnect). You can use the player's earlier saved session data to update that object so that it returns to the same state before disconnecting. In those cases, you would need to keep all the important data that you want to restore and map it to the player using your identification system. You can save this data when a player disconnects or update it periodically. You can then use the `OnNetworkSpawn` event on the Player Object's `NetworkBehavior`(s) to get this data and apply it where needed.
+The best way to reconnect players depends on your game. For example, if you use a [Player Object](../components/core/playerobjects.md), a new `Default Player Prefab` automatically spawns when a player connects to the game (including when they reconnect). You can use the player's earlier saved session data to update that object so that it returns to the same state before disconnecting. In those cases, you would need to keep all the important data that you want to restore and map it to the player using your identification system. You can save this data when a player disconnects or update it periodically. You can then use the `OnNetworkSpawn` event on the Player Object's `NetworkBehavior`(s) to get this data and apply it where needed.
In cases where we don't use the Player Object approach and instead manually attribute client ownership to NetworkObject(s), we can keep the objects that a player owns when they disconnect, and set the reconnected player as their new owner. To accomplish this, the only data we would need to keep would be the mapping between those objects and their owning player's identifier, then when a player reconnects we can use this mapping to set them as the new owner. This mapping can be as simple as a dictionary mapping the player identifier with the `NetworkObjectId`(s) of the NetworkObject(s) they own. Then, in the `OnClientConnectedCallback` from the NetworkManager, the server can set the ownership of these objects.
diff --git a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/singleplayer.md b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/singleplayer.md
new file mode 100644
index 0000000000..b0d54e88be
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/singleplayer.md
@@ -0,0 +1,18 @@
+# Single player sessions
+
+Netcode for GameObjects provides a [SinglePlayerTransport](xref:Unity.Netcode.Transports.SinglePlayer.SinglePlayerTransport) which derives from [NetworkTransport](xref:Unity.Netcode.NetworkTransport).
+
+This provides the ability to run a hosted session using the single player transport without having to modify your primary netcode script.
+
+## Adding the single player transport
+
+- Add the `SinglePlayerTransport` to your NetworkManager.
+- You can create a custom `MonoBehaviour` component to handle your connection flow or you can derive from `NetworkManager` and add additional methods/logic to handle starting a single player session or multiplayer session.
+ - When starting a single player session, prior to starting the NetworkManager as a host (_required_), you will want to assign the `SinglePlayerTransport` to the `NetworkManager.NetworkConfig.NetworkTransport`.
+ - When starting a multiplayer session, prior to starting the NetworkManager, you will want to assign the `UnityTransport` (_or any other `NetworkTransport` derived class that you might use for multiplayer sessions_) to the `NetworkManager.NetworkConfig.NetworkTransport`.
+
+## Example script
+
+Below is an example component script that provides a single method to start a single or multi player session:
+
+[!code-cs[](../../Tests/Runtime/DocumentationCodeSamples/Configuration/SinglePlayerSessions.cs#SinglePlayerTransportExample)]
diff --git a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/transports.md b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/transports.md
index 1939d8a0ea..783f0f633c 100644
--- a/com.unity.netcode.gameobjects/Documentation~/advanced-topics/transports.md
+++ b/com.unity.netcode.gameobjects/Documentation~/advanced-topics/transports.md
@@ -16,7 +16,7 @@ A transport layer can provide:
## Unity Transport package
-Netcode's default transport Unity Transport is an entire transport layer that you can use to add multiplayer and network features to your project with or without Netcode. See the Transport [documentation](../../../transport/current/about) for more information and how to [install](../../../transport/current/install).
+Netcode's default transport Unity Transport is an entire transport layer that you can use to add multiplayer and network features to your project with or without Netcode. Refer to the Transport [documentation](https://docs.unity3d.com/Packages/com.unity.transport@latest) for more information and how to [install](https://docs.unity3d.com/Packages/com.unity.transport@latest?subfolder=/manual/install.html).
## Unity's UNet Transport Layer API
diff --git a/com.unity.netcode.gameobjects/Documentation~/basics/custom-networkvariables.md b/com.unity.netcode.gameobjects/Documentation~/basics/custom-networkvariables.md
index c2c1f97286..7c6dd428a7 100644
--- a/com.unity.netcode.gameobjects/Documentation~/basics/custom-networkvariables.md
+++ b/com.unity.netcode.gameobjects/Documentation~/basics/custom-networkvariables.md
@@ -2,6 +2,9 @@
In addition to the standard [`NetworkVariable`s](networkvariable.md) available in Netcode for GameObjects, you can also create custom `NetworkVariable`s for advanced implementations. The `NetworkVariable` and `NetworkList` classes were created as `NetworkVariableBase` class implementation examples. While the `NetworkVariable` class is considered production ready, you might run into scenarios where you have a more advanced implementation in mind. In this case, you can create your own custom implementation.
+> [!NOTE]
+> Read the [Serialization overview](../advanced-topics/serialization/serialization-overview.md) page to understand how Netcode for GameObjects handles serialization.
+
To create your own `NetworkVariableBase`-derived container, you should:
1. Create a class deriving from `NetworkVariableBase`.
@@ -16,11 +19,14 @@ To create your own `NetworkVariableBase`-derived container, you should:
The way you read and write `NetworkVariable`s changes depending on the type you use.
-* Known, non-generic types: Use `FastBufferReader.ReadValue` to read from and `FastBufferWriter.WriteValue` to write to the `NetworkVariable` value.
-* Integer types: This type gives you the option to use `BytePacker` and `ByteUnpacker` to compress the `NetworkVariable` value. This process can save bandwidth but adds CPU processing time.
+* Known, non-generic types can use [`FastBufferWriter` and `FastBufferReader`](../advanced-topics/fastbufferwriter-fastbufferreader.md) to serialize the `NetworkVariable` value.
+* Integer types: This type gives you the option to use [`BytePacker` and `ByteUnpacker`](../advanced-topics/fastbufferwriter-fastbufferreader.md#packing) to compress the `NetworkVariable` value. This process can save bandwidth but adds CPU processing time.
* Generic types: Use serializers that Unity generates based on types discovered during a compile-time code generation process. This means you need to tell Unity's code generation algorithm which types to generate serializers for. To tell Unity which types to serialize, use the following methods:
* Use `GenerateSerializationForTypeAttribute` to serialize hard-coded types.
* Use `GenerateSerializationForGenericParameterAttribute` to serialize generic types.
+* Types implementing [`INetworkSerializable`](../advanced-topics/serialization/inetworkserializable.md) can also be serialized using `FastBufferWriter` and `FastBufferReader`.
+
+Read more about [custom serialization](../advanced-topics/custom-serialization.md) for more approaches to customizing serialization.
### Serialize a hard-coded type
@@ -66,175 +72,22 @@ For dynamically-allocated types with a value that isn't `null` (for example, man
You can use `AreEqual` to determine if a value is different from the value that `Duplicate` cached. This avoids sending the same value multiple times. You can also use the previous value that `Duplicate` cached to calculate deltas to use in `ReadDelta` and `WriteDelta`.
-The type you use must be serializable according to the [support types list above](#supported-types). Each type needs its own serializer instantiated, so this step tells the codegen which types to create serializers for. Unity's code generator assumes that all `NetworkVariable` types exist as fields inside NetworkBehaviour types. This means that Unity only inspects fields inside NetworkBehaviour types to identify the types to create serializers for.
+The type you use must be serializable according to the [supported types list](./networkvariable.md#supported-types). Each type needs its own serializer instantiated, so this step tells the codegen which types to create serializers for. Unity's code generator assumes that all `NetworkVariable` types exist as fields inside NetworkBehaviour types. This means that Unity only inspects fields inside NetworkBehaviour types to identify the types to create serializers for.
-## Custom NetworkVariable example
+> [!NOTE]
+> These attributes won't generate delta serialization. If you would like to customize how deltas are sent when a custom value has partially changed, refer to [`UserNetworkVariableSerialization`](../advanced-topics/custom-serialization.md#networkvariable).
+
+## Custom NetworkVariableBase example
This example shows a custom `NetworkVariable` type to help you understand how you might implement such a type. In the current version of Netcode for GameObjects, this example is possible without using a custom `NetworkVariable` type; however, for more complex situations that aren't natively supported, this basic example should help inform you of how to approach the implementation:
- ```csharp
- /// Using MyCustomNetworkVariable within a NetworkBehaviour
- public class TestMyCustomNetworkVariable : NetworkBehaviour
- {
- public MyCustomNetworkVariable CustomNetworkVariable = new MyCustomNetworkVariable();
- public MyCustomGenericNetworkVariable CustomGenericNetworkVariable = new MyCustomGenericNetworkVariable();
- public override void OnNetworkSpawn()
- {
- if (IsServer)
- {
- for (int i = 0; i < 4; i++)
- {
- var someData = new SomeData();
- someData.SomeFloatData = (float)i;
- someData.SomeIntData = i;
- someData.SomeListOfValues.Add((ulong)i + 1000000);
- someData.SomeListOfValues.Add((ulong)i + 2000000);
- someData.SomeListOfValues.Add((ulong)i + 3000000);
- CustomNetworkVariable.SomeDataToSynchronize.Add(someData);
- CustomNetworkVariable.SetDirty(true);
-
- CustomGenericNetworkVariable.SomeDataToSynchronize.Add(i);
- CustomGenericNetworkVariable.SetDirty(true);
- }
- }
- }
- }
-
- /// Bare minimum example of NetworkVariableBase derived class
- [Serializable]
- public class MyCustomNetworkVariable : NetworkVariableBase
- {
- /// Managed list of class instances
- public List SomeDataToSynchronize = new List();
-
- ///
- /// Writes the complete state of the variable to the writer
- ///
- /// The stream to write the state to
- public override void WriteField(FastBufferWriter writer)
- {
- // Serialize the data we need to synchronize
- writer.WriteValueSafe(SomeDataToSynchronize.Count);
- foreach (var dataEntry in SomeDataToSynchronize)
- {
- writer.WriteValueSafe(dataEntry.SomeIntData);
- writer.WriteValueSafe(dataEntry.SomeFloatData);
- writer.WriteValueSafe(dataEntry.SomeListOfValues.Count);
- foreach (var valueItem in dataEntry.SomeListOfValues)
- {
- writer.WriteValueSafe(valueItem);
- }
- }
- }
-
- ///
- /// Reads the complete state from the reader and applies it
- ///
- /// The stream to read the state from
- public override void ReadField(FastBufferReader reader)
- {
- // De-Serialize the data being synchronized
- var itemsToUpdate = (int)0;
- reader.ReadValueSafe(out itemsToUpdate);
- SomeDataToSynchronize.Clear();
- for (int i = 0; i < itemsToUpdate; i++)
- {
- var newEntry = new SomeData();
- reader.ReadValueSafe(out newEntry.SomeIntData);
- reader.ReadValueSafe(out newEntry.SomeFloatData);
- var itemsCount = (int)0;
- var tempValue = (ulong)0;
- reader.ReadValueSafe(out itemsCount);
- newEntry.SomeListOfValues.Clear();
- for (int j = 0; j < itemsCount; j++)
- {
- reader.ReadValueSafe(out tempValue);
- newEntry.SomeListOfValues.Add(tempValue);
- }
- SomeDataToSynchronize.Add(newEntry);
- }
- }
-
- public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
- {
- // Do nothing for this example
- }
-
- public override void WriteDelta(FastBufferWriter writer)
- {
- // Do nothing for this example
- }
- }
-
- /// Bare minimum example of generic NetworkVariableBase derived class
- [Serializable]
- [GenerateSerializationForGenericParameter(0)]
- public class MyCustomGenericNetworkVariable : NetworkVariableBase
- {
- /// Managed list of class instances
- public List SomeDataToSynchronize = new List();
-
- ///
- /// Writes the complete state of the variable to the writer
- ///
- /// The stream to write the state to
- public override void WriteField(FastBufferWriter writer)
- {
- // Serialize the data we need to synchronize
- writer.WriteValueSafe(SomeDataToSynchronize.Count);
- for (var i = 0; i < SomeDataToSynchronize.Count; ++i)
- {
- var dataEntry = SomeDataToSynchronize[i];
- // NetworkVariableSerialization is used for serializing generic types
- NetworkVariableSerialization.Write(writer, ref dataEntry);
- }
- }
-
- ///
- /// Reads the complete state from the reader and applies it
- ///
- /// The stream to read the state from
- public override void ReadField(FastBufferReader reader)
- {
- // De-Serialize the data being synchronized
- var itemsToUpdate = (int)0;
- reader.ReadValueSafe(out itemsToUpdate);
- SomeDataToSynchronize.Clear();
- for (int i = 0; i < itemsToUpdate; i++)
- {
- T newEntry = default;
- // NetworkVariableSerialization is used for serializing generic types
- NetworkVariableSerialization.Read(reader, ref newEntry);
- SomeDataToSynchronize.Add(newEntry);
- }
- }
-
- public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
- {
- // Do nothing for this example
- }
-
- public override void WriteDelta(FastBufferWriter writer)
- {
- // Do nothing for this example
- }
- }
-
- /// Example managed class used as the item type in the
- /// MyCustomNetworkVariable.SomeDataToSynchronize list
- [Serializable]
- public class SomeData
- {
- public int SomeIntData = default;
- public float SomeFloatData = default;
- public List SomeListOfValues = new List();
- }
- ```
+[!code-cs[](../../Tests/Runtime/DocumentationCodeSamples/NetworkVariable/CustomNetworkVariable.cs#TestMyCustomNetworkVariable)]
While the above example isn't the recommended way to synchronize a list where the number or order of elements in the list often changes, it's an example of how you can define your own rules using `NetworkVariableBase`.
You can test the code above by:
-- Using the above code with a project that includes Netcode for GameObjects v1.0 (or higher).
+
+- Using the above code with a project that includes Netcode for GameObjects.
- Adding the `TestMyCustomNetworkVariable` component to an in-scene placed NetworkObject.
- Creating a stand alone build and running that as a host or server.
- Running the same scene within the Editor and connecting as a client.
diff --git a/com.unity.netcode.gameobjects/Documentation~/basics/networkvariable.md b/com.unity.netcode.gameobjects/Documentation~/basics/networkvariable.md
index 0ea6c445e8..cfdd037143 100644
--- a/com.unity.netcode.gameobjects/Documentation~/basics/networkvariable.md
+++ b/com.unity.netcode.gameobjects/Documentation~/basics/networkvariable.md
@@ -148,43 +148,277 @@ The [synchronization and notification example](#synchronization-and-notification
The `OnValueChanged` example shows a simple server-authoritative `NetworkVariable` being used to track the state of a door (open or closed) using an RPC that's sent to the server. Each time the door is used by a client, the `Door.ToggleStateRpc` is invoked and the server-side toggles the state of the door. When the `Door.State.Value` changes, all connected clients are synchronized to the (new) current `Value` and the `OnStateChanged` method is invoked locally on each client.
```csharp
-public class Door : NetworkBehaviour
+using System.Runtime.CompilerServices;
+using Unity.Netcode;
+using UnityEngine;
+
+///
+/// Example of using a to drive changes
+/// in state.
+///
+///
+/// This is a simple state driven door example.
+/// This script was written with recommended usages patterns in mind.
+///
+public class Door : NetworkBehaviour, INetworkUpdateSystem
{
- public NetworkVariable State = new NetworkVariable();
+ ///
+ /// The two door states.
+ ///
+ public enum DoorStates
+ {
+ Closed,
+ Open
+ }
+ ///
+ /// Initializes the door to a specific state (server side) when first spawned.
+ ///
+ [Tooltip("Configures the door's initial state when 1st spawned.")]
+ public DoorStates InitialState = DoorStates.Closed;
+
+ ///
+ /// Used for example purposes.
+ /// When true, only the server can open and close the door.
+ /// Clients will receive a console log saying they could not open the door.
+ ///
+ public bool IsLocked;
+
+ ///
+ /// A simple door state where the server has write permissions and everyone has read permissions.
+ ///
+ private NetworkVariable m_State = new NetworkVariable(default, NetworkVariableReadPermission.Everyone, NetworkVariableWritePermission.Server);
+
+ ///
+ /// The current state of the door.
+ ///
+ public DoorStates CurrentState => m_State.Value;
+
+ ///
+ /// Invoked while the is in the process of
+ /// being spawned.
+ ///
public override void OnNetworkSpawn()
{
- State.OnValueChanged += OnStateChanged;
+ // The write authority (server) doesn't need to know about its
+ // own changes (for this example) since it's the "single point
+ // of truth" for the door instance.
+ if (IsServer)
+ {
+ // Host/Server:
+ // Applies the configurable state upon spawning.
+ m_State.Value = InitialState;
+ }
+ else
+ {
+ // Clients:
+ // Subscribe to changes in the door's state.
+ m_State.OnValueChanged += OnStateChanged;
+ }
}
- public override void OnNetworkDespawn()
+ ///
+ /// Invoked once the door and all associated components
+ /// have finished the spawn process.
+ ///
+ protected override void OnNetworkPostSpawn()
{
- State.OnValueChanged -= OnStateChanged;
+ // Everyone updates their door state when finished spawning the door
+ // to ensure the door reflects (visually) its current state.
+ UpdateFromState();
+
+ // Begin updating this NetworkBehaviour instance once all
+ // netcode related components have finished the spawn process.
+ NetworkUpdateLoop.RegisterNetworkUpdate(this, NetworkUpdateStage.Update);
+ base.OnNetworkPostSpawn();
}
- public void OnStateChanged(bool previous, bool current)
+ ///
+ /// Example of using the usage pattern
+ /// where it only updates while spawned.
+ ///
+ /// The current update stage being invoked.
+ public void NetworkUpdate(NetworkUpdateStage updateStage)
{
- // note: `State.Value` will be equal to `current` here
- if (State.Value)
+ switch (updateStage)
{
- // door is open:
- // - rotate door transform
- // - play animations, sound etc.
+ case NetworkUpdateStage.Update:
+ {
+ if (Input.GetKeyDown(KeyCode.Space))
+ {
+ Interact();
+ }
+ break;
+ }
+ }
+ }
+
+ ///
+ /// Invoked just before this instance runs through its despawn
+ /// sequence. A good time to unsubscribe from things.
+ ///
+ public override void OnNetworkPreDespawn()
+ {
+ if (!IsServer)
+ {
+ m_State.OnValueChanged -= OnStateChanged;
+ }
+
+ // Stop updating this NetworkBehaviour instance prior to running
+ // through the despawn process.
+ NetworkUpdateLoop.RegisterNetworkUpdate(this, NetworkUpdateStage.Update);
+ base.OnNetworkPreDespawn();
+ }
+
+ ///
+ /// Server makes changes to the state.
+ /// Clients receive the changes in state.
+ ///
+ ///
+ /// When the previous state equals the current state, we are a client
+ /// that is doing its first synchronization of this door instance.
+ ///
+ /// The previous state.
+ /// The current state.
+ public void OnStateChanged(DoorStates previous, DoorStates current)
+ {
+ UpdateFromState();
+ }
+
+ ///
+ /// Invoke when the state is updated to apply the change
+ /// in door state to the door asset itself.
+ ///
+ private void UpdateFromState()
+ {
+ switch(m_State.Value)
+ {
+ case DoorStates.Closed:
+ {
+ // door is open:
+ // - rotate door transform
+ // - play animations, sound etc.
+ ///
+ /// Override to apply specific checks (like a player having the right
+ /// key to open the door) or make it a non-virtual class and add logic
+ /// directly to this method.
+ ///
+ /// The player attempting to open the door.
+ ///
+ protected virtual bool CanPlayerToggleState(NetworkObject player)
+ {
+ // For this example, if the door "is locked" then clients will
+ // not be able to open the door but the host-client's player can.
+ return !IsLocked || player.IsOwnedByServer;
+ }
+
+ ///
+ /// Invoked by either a host or clients to interact with the door.
+ ///
+ public void Interact()
+ {
+ // Optional:
+ // This is only if you want clients to be able to
+ // interact with doors. A dedicated server would not
+ // be able to do this since it does not have a player.
+ if (IsServer && !IsHost)
+ {
+ // Optional to log a warning about this.
+ return;
+ }
+
+ if (IsHost)
+ {
+ ToggleState(NetworkManager.LocalClientId);
+ }
+ else
+ {
+ // Clients send an RPC to server (write authority) who applies the
+ // change in state that will be synchronized with all client observers.
+ ToggleStateRpc();
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ private DoorStates NextToggleState()
+ {
+ return m_State.Value == DoorStates.Open ? DoorStates.Closed : DoorStates.Open;
+ }
+
+ ///
+ /// Invoked only server-side
+ /// Primary method to handle toggling the door state.
+ ///
+ /// The client toggling the door state.
+ private void ToggleState(ulong clientId)
+ {
+ // Get the server-side client player instance
+ var playerObject = NetworkManager.SpawnManager.GetPlayerNetworkObject(clientId);
+ if (playerObject != null)
+ {
+ var nextToggleState = NextToggleState();
+ if (CanPlayerToggleState(playerObject))
+ {
+ // Host toggles the state
+ m_State.Value = nextToggleState;
+ UpdateFromState();
+ }
+ else
+ {
+ ToggleStateFailRpc(nextToggleState, RpcTarget.Single(clientId, RpcTargetUse.Temp));
+ }
}
else
{
- // door is closed:
- // - rotate door transform
- // - play animations, sound etc.
+ // Optional as to how you handle this. Since ToggleState is only invoked by
+ // sever-side only script, this could mean many things depending upon whether
+ // or not a client could interact with something and not have a player object.
+ // If that is the case, then don't even bother checking for a player object.
+ // If that is not the case, then there could be a timing issue between when
+ // something can be "interacted with" and when a player is about to be de-spawned.
+ // For this example, we just log a warning as this example was built with
+ // the requirement that a client has a spawned player object that is used for
+ // reference to determine if the client's player can toggle the state of the
+ // door or not.
+ NetworkLog.LogWarningServer($"Client-{clientId} has no spawned player object!");
}
}
- [Rpc(SendTo.Server)]
- public void ToggleStateRpc()
+ ///
+ /// Invoked by clients.
+ /// Re-directs to the common method.
+ ///
+ /// includes that is automatically populated for you.
+ [Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Everyone)]
+ private void ToggleStateRpc(RpcParams rpcParams = default)
+ {
+ ToggleState(rpcParams.Receive.SenderClientId);
+ }
+
+ ///
+ /// Optional:
+ /// Handling when a player cannot open a door.
+ ///
+ /// includes that is automatically populated for you.
+ [Rpc(SendTo.SpecifiedInParams, InvokePermission = RpcInvokePermission.Server)]
+ private void ToggleStateFailRpc(DoorStates doorState, RpcParams rpcParams = default)
{
- // this will cause a replication over the network
- // and ultimately invoke `OnValueChanged` on receivers
- State.Value = !State.Value;
+ // Provide player feedback that toggling failed.
+ Debug.Log($"Failed to {doorState} the door!");
}
}
```
@@ -318,7 +552,7 @@ public class PlayerState : NetworkBehaviour
## Complex types
-Almost all of the examples on this page have been focused around numeric [value types](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/value-types). Netcode for GameObjects also supports complex types and can support both unmanaged types *and* managed types (although avoiding managed types where possible will improve your game's performance).
+Any type that implements the [`INetworkSerializable`](../advanced-topics/serialization/inetworkserializable.md) interface can be used inside a `NetworkVariable`. To synchronize a custom type that is not supported by the default serialization provided by Netcode for GameObjects, implement this interface to allow it to be used inside a `NetworkVariable`.
### Synchronizing complex types example
@@ -348,7 +582,7 @@ public class PlayerState : NetworkBehaviour
void Awake()
{
//NetworkList can't be initialized at declaration time like NetworkVariable. It must be initialized in Awake instead.
- //If you do initialize at declaration, you will run into Memmory leak errors.
+ //If you do initialize at declaration, you will run into Memory leak errors.
TeamAreaWeaponBoosters = new NetworkList();
}
@@ -473,88 +707,12 @@ public struct AreaWeaponBooster : INetworkSerializable, System.IEquatable [!NOTE]
-> The `NetworkVariable` and `NetworkList` classes were created as `NetworkVariableBase` class implementation examples. While the `NetworkVariable` class is considered production ready, you might run into scenarios where you have a more advanced implementation in mind. In this case, we encourage you to create your own custom implementation.
-
-To create your own `NetworkVariableBase` derived container, you should:
-
-- Create a class deriving from `NetworkVariableBase`.
-
-- Assure the the following methods are overridden:
- - `void WriteField(FastBufferWriter writer)`
- - `void ReadField(FastBufferReader reader)`
- - `void WriteDelta(FastBufferWriter writer)`
- - `void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)`
-- Depdending upon your custom `NetworkVariableBase` container, you might look at `NetworkVariable` or `NetworkList` to see how those two examples were implemented.
-
-
-
-#### NetworkVariableSerialization<T>
-
-The way you read and write network variables changes depending on the type you use.
-
-* Known, non-generic types: Use `FastBufferReader.ReadValue` to read from and `FastBufferWriter.WriteValue` to write to the network variable value.
-* Integer types: This type gives you the option to use `BytePacker` and `ByteUnpacker` to compress the network variable value. This process can save bandwidth but adds CPU processing time.
-* Generic types: Use serializers that Unity generates based on types discovered during a compile-time code generation process. This means you need to tell Unity's code generation algorithm which types to generate serializers for. To tell Unity which types to serialize, use the following methods:
- * Use `GenerateSerializationForTypeAttribute` to serialize hard-coded types.
- * Use `GenerateSerializationForGenericParameterAttribute` to serialize generic types.
- To learn how to use these methods, refer to [Network variable serialization](#network-variable-serialization).
-
-##### Tell Unity to serialize a hard-coded type
-The following code example uses `GenerateSerializationForTypeAttribute` to generate serialization for a specific hard-coded type:
-```csharp
-[GenerateSerializationForType(typeof(Foo))]
-public class MyNetworkVariableTypeUsingFoo : NetworkVariableBase {}
-```
-
-You can call a type that you know the name of with the `FastBufferReader` or `FastBufferWriter` methods. These methods don't work for Generic types because the name of the type is unknown.
-##### Tell Unity to serialize a generic type
-The following code example uses `GenerateSerializationForGenericParameterAttribute` to generate serialization for a specific Generic parameter in your `NetworkVariable` type:
-```csharp
-[GenerateSerializationForGenericParameter(0)]
-public class MyNetworkVariableType : NetworkVariableBase {}
-```
-
-This attribute accepts an integer that indicates which parameter in the type to generate serialization for. This value is 0-indexed, which means that the first type is 0, the second type is 1, and so on.
-The following code example places the attribute more than once on one class to generate serialization for multiple types, in this case,`TFirstType` and `TSecondType:
-
-```csharp
-[GenerateSerializationForGenericParameter(0)]
-[GenerateSerializationForGenericParameter(1)]
-public class MyNetworkVariableType : NetworkVariableBase {}
-```
-
-
-The `GenerateSerializationForGenericParameterAttribute` and `GenerateSerializationForTypeAttribute` attributes make Unity's code generation create the following methods:
-
-```csharp
-NetworkVariableSerialization.Write(FastBufferWriter writer, ref T value);
-NetworkVariableSerialization.Read(FastBufferWriter writer, ref T value);
-NetworkVariableSerialization.Duplicate(in T value, ref T duplicatedValue);
-NetworkVariableSerialization.AreEqual(in T a, in T b);
-```
-
-For dynamically allocated types with a value that isn't `null` (for example, managed types and collections like NativeArray and NativeList) call `Read` to read the value in the existing object and write data into it directy (in-place). This avoids more allocations.
-
-You can use `AreEqual` to determine if a value is different from the value that `Duplicate` cached. This avoids sending the same value multiple times. You can also use the previous value that `Duplicate` cached to calculate deltas to use in `ReadDelta` and `WriteDelta`.
-
-The type you use must be serializable according to the "Supported Types" list above. Each type needs its own serializer instantiated, so this step tells the codegen which types to create serializers for.
-
-> [!NOTE] Unity's code generator assumes that all `NetworkVariable` types exist as fields inside NetworkBehaviour types. This means that Unity only inspects fields inside NetworkBehaviour types to identify the types to create serializers for.
-
- ### Custom NetworkVariable Example
-
-This example shows a custom `NetworkVariable` type to help you understand how you might implement such a type. In the current version of Netcode for GameObjects, this example is possible without using a custom `NetworkVariable` type; however, for more complex situations that aren't natively supported, this basic example should help inform you of how to approach the implementation:
-
-Looking at the read and write segments of code within `AreaWeaponBooster.NetworkSerialize`, the nested complex type property `ApplyWeaponBooster` handles its own serialization and de-serialization. The `ApplyWeaponBooster`'s implemented `NetworkSerialize` method serializes and deserializes any `AreaWeaponBooster` type property. This design approach can help reduce code replication while providing a more modular foundation to build even more complex, nested types.
-
+Further information on customizing the serialization of complex types can be found in [custom serialization](../advanced-topics/custom-serialization.md#networkvariable).
## Strings
-While `NetworkVariable` does support managed `INetworkSerializable` types, strings aren't in the list of supported types. This is because strings in C# are immutable types, preventing them from being deserialized in-place, so every update to a `NetworkVariable` would cause a Garbage Collected allocation to create the new string, which may lead to performance problems.
+While `NetworkVariable` does support managed `INetworkSerializable` types, strings aren't in the [list of supported types](#supported-types). This is because strings in C# are immutable types, preventing them from being deserialized in-place, so every update to a `NetworkVariable` would cause a Garbage Collected allocation to create the new string, which may lead to performance problems.
-While it's technically possible to support strings using custom serialization through `UserNetworkVariableSerialization`, it isn't recommended to do so due to the performance implications that come with it. Instead, we recommend using one of the `Unity.Collections.FixedString` value types. In the below example, we used a `FixedString128Bytes` as the `NetworkVariable` value type. On the server side, it changes the string value each time you press the space bar on the server or host instance. Joining clients will be synchronized with the current value applied on the server side, and each time you hit the space bar on the server side, the client synchronizes with the changed string.
+While it's technically possible to support strings using custom serialization through [`UserNetworkVariableSerialization`](../advanced-topics/custom-serialization.md#networkvariable), it isn't recommended to do so due to the performance implications that come with it. Instead, it's recommended to use one of the `Unity.Collections.FixedString` value types. In the below example, a `FixedString128Bytes` is the `NetworkVariable` value type. On the server side, it changes the string value each time you press the space bar on the server or host instance. Joining clients will be synchronized with the current value applied on the server side, and each time you hit the space bar on the server side, the client synchronizes with the changed string.
> [!NOTE]
> `NetworkVariable` won't serialize the entire 128 bytes each time the `Value` is changed. Only the number of bytes that are actually used to store the string value will be sent, no matter which size of `FixedString` you use.
@@ -621,3 +779,9 @@ public class TestFixedString : NetworkBehaviour
> [!NOTE]
> The above example uses a pre-set list of strings to cycle through for example purposes only. If you have a predefined set of text strings as part of your actual design then you would not want to use a FixedString to handle synchronizing the changes to `m_TextString`. Instead, you would want to use a `uint` for the type `T` where the `uint` was the index of the string message to apply to `m_TextString`.
+
+### Delta updates
+
+To save bandwidth, `NetworkVariables` can send delta updates. A delta is a compact description of what changed since the last sync. By default, [collection types](#using-collections-with-networkvariables) all support sending delta updates. This means adding a single item to a large list doesn't need to send the entire list over the network. For complex types, it is often worth considering whether sending deltas will improve bandwidth. Delta serialization can be configured via [`UserNetworkVariableSerialization`](../advanced-topics/custom-serialization.md#serializing-delta-updates).
+
+When a NetworkObject is spawned or a late-joining client first sees it, every `NetworkVariable` will be serialized in full. This allows game clients to start receiving deltas from a known state.
diff --git a/com.unity.netcode.gameobjects/Documentation~/basics/object-spawning.md b/com.unity.netcode.gameobjects/Documentation~/basics/object-spawning.md
index 7fdd95ee4d..b72213f32e 100644
--- a/com.unity.netcode.gameobjects/Documentation~/basics/object-spawning.md
+++ b/com.unity.netcode.gameobjects/Documentation~/basics/object-spawning.md
@@ -30,7 +30,7 @@ When using a [server authoritative networking model](../terms-concepts/authority
To spawn a network prefab, you must first create an instance of the network prefab and then invoke the spawn method on the NetworkObject component of the instance you created. In most cases, you will want to keep the NetworkObject component attached to the root GameObject of the network prefab.
-Refer to [NetworkObject ownership](../advanced-topics/networkobject-ownership.md) for more information.
+Refer to [NetworkObject ownership](../components/core/networkobject-ownership.md) for more information.
The following is a basic example of how to spawn a network prefab instance:
diff --git a/com.unity.netcode.gameobjects/Documentation~/basics/scenemanagement/custom-management.md b/com.unity.netcode.gameobjects/Documentation~/basics/scenemanagement/custom-management.md
index dff54d2da4..ffb1cde762 100644
--- a/com.unity.netcode.gameobjects/Documentation~/basics/scenemanagement/custom-management.md
+++ b/com.unity.netcode.gameobjects/Documentation~/basics/scenemanagement/custom-management.md
@@ -39,7 +39,7 @@ Once you've registered your in-scene placed Network Prefabs with your `NetworkPr
> When a client first connects, it deletes any in-scene placed `NetworkObjects` in any of the scenes it has currently loaded. When using a custom scene management solution, in-scene placed NetworkObjects are actually dynamically spawned. This means any changes you make to your in-scene placed Network Prefabs will *not* be synchronized with clients automatically.
### Synchronizing In-Scene Placed Network Prefab Instances
-If you want to change an in-scene placed network prefab instance, you need to handle the serialization of these settings yourself. You can do this by overriding `NetworkBehaviour.OnSynchronize` and serializing any property updates you want to have synchronized with clients when they join. [Read More About OnSynchronize Here](../../components/core/networkbehaviour.md#prespawn-synchronization).
+If you want to change an in-scene placed network prefab instance, you need to handle the serialization of these settings yourself. You can do this by overriding `NetworkBehaviour.OnSynchronize` and serializing any property updates you want to have synchronized with clients when they join. [Read More About OnSynchronize Here](../../components/core/networkbehaviour-synchronize.md#prespawn-synchronization-with-onsynchronize).
## Starting a Netcode Enabled Game Session
The recommended way of starting session using your own scene management solution is to assure that when a client attempts to join a netcode game session it should already have (as best as possible) any scenes that the server might have loaded. While this does not assure that your newly connecting client will load any additional scenes that might have been loaded, using this approach initially will get you started so you can then come up with a strategy to handling:
diff --git a/com.unity.netcode.gameobjects/Documentation~/basics/scenemanagement/inscene-placed-networkobjects.md b/com.unity.netcode.gameobjects/Documentation~/basics/scenemanagement/inscene-placed-networkobjects.md
index 6bc209722b..617a8f5f36 100644
--- a/com.unity.netcode.gameobjects/Documentation~/basics/scenemanagement/inscene-placed-networkobjects.md
+++ b/com.unity.netcode.gameobjects/Documentation~/basics/scenemanagement/inscene-placed-networkobjects.md
@@ -78,6 +78,9 @@ private void Start()
> [!NOTE]
> Once migrated into the DDoL, migrating the in-scene placed NetworkObject back into a different scene after it has already been spawned will cause soft synchronization errors with late-joining clients. Once in the DDoL it should stay in the DDoL. This is only for scene switching. If you aren't using scene switching, then it's recommended to use an additively loaded scene and keep that scene loaded for as long as you wish to persist the in-scene placed NetworkObject(s) being used for state management purposes.
+> [!WARNING]
+> Manually calling `DontDestroyOnLoad(gameObject)` is only supported for the scene-switching manager scenario described above (that is, a single in-scene placed NetworkObject used for state management that's migrated into the DDoL and stays there). Marking ordinary in-scene placed NetworkObjects as `DontDestroyOnLoad` isn't supported and can cause the object's `GlobalObjectIdHash` to no longer resolve after a scene change, resulting in errors such as "NetworkPrefab hash was not found!". To persist in-scene placed NetworkObjects across scene changes, prefer keeping them in an additively loaded scene that stays loaded for the duration of the session rather than using `DontDestroyOnLoad`.
+
## Complex in-scene NetworkObjects
The most common mistake when using an in-scene placed NetworkObject is to try and use it like a dynamically spawned NetworkObject. When trying to decide if you should use an in-scene placed or dynamically spawned NetworkObject, you should ask yourself the following questions:
@@ -181,9 +184,13 @@ public class MyInSceneNetworkObjectBehaviour : NetworkBehaviour
> [!NOTE]
> You only need to enable the NetworkObject on the server-side to be able to respawn it. Netcode for GameObjects only enables a disabled in-scene placed NetworkObject on the client-side if the server-side spawns it. This **does not** apply to dynamically spawned `NetworkObjects`. Refer to [the object pooling page](../../advanced-topics/object-pooling.md) for an example of recycling dynamically spawned NetworkObjects.
+### Pre-disabled in-scene placed NetworkObjects
+
+To initialize an in-scene placed NetworkObject in a disabled state and spawn it later, set its GameObject to inactive in the Editor while the respective scene is open. Once a networked session begins, you can re-enable and spawn it at any time.
+
### Setting an in-scene placed NetworkObject to a despawned state when instantiating
-Since in-scene placed NetworkObjects are automatically spawned when their respective scene has finished loading during a network session, you might run into the scenario where you want it to start in a despawned state until a certain condition has been met. To do this, you need to add some additional code in the `OnNetworkSpawn` part of your NetworkBehaviour component:
+To programmatically disable an in-scene placed NetworkObject, add some additional code in the `OnNetworkSpawn` part of a NetworkBehaviour component:
```csharp
using UnityEngine;
@@ -225,7 +232,7 @@ The above example keeps track of whether the in-scene placed NetworkObject has s
### Synchronizing late-joining clients when an in-scene placed NetworkObject has been despawned and destroyed
-Referring back to the [section on complex in-scene NetworkObjects](#complex-in-scene-networkobjects), it's recommended to use dynamically spawned NetworkObjects if you intend to destroy the object when it's despawned. However, if either despawning but not destroying or using the [hybrid approach](#a-hybrid-approach-example) don't appear to be options for your project's needs, then there are two other possible (but not recommended) alternatives:
+Referring back to the [section on complex in-scene NetworkObjects](#complex-in-scene-networkobjects), it's recommended to use dynamically spawned NetworkObjects if you intend to destroy the object when it's despawned. However, if either despawning but not destroying or using the [hybrid approach](#hybrid-approach) don't appear to be options for your project's needs, then there are two other possible (but not recommended) alternatives:
- Have another in-scene placed NetworkObject track which in-scene placed NetworkObjects have been destroyed and upon a player late-joining (that is, `OnClientConnected`) you would need to send the newly-joined client the list of in-scene placed NetworkObjects that it should destroy. This adds an additional in-scene placed NetworkObject to your scene hierarchy and will consume memory keeping track of what was destroyed.
- Disable the visual and physics-related components (in Editor as a default) of the in-scene placed NetworkObject(s) in question and only enable them in `OnNetworkSpawn`. This doesn't delete/remove the in-scene placed NetworkObject(s) for the late-joining client and can be tricky to implement without running into edge case scenario bugs.
diff --git a/com.unity.netcode.gameobjects/Documentation~/basics/scenemanagement/scene-events.md b/com.unity.netcode.gameobjects/Documentation~/basics/scenemanagement/scene-events.md
index 817affd33f..c01ffa1df5 100644
--- a/com.unity.netcode.gameobjects/Documentation~/basics/scenemanagement/scene-events.md
+++ b/com.unity.netcode.gameobjects/Documentation~/basics/scenemanagement/scene-events.md
@@ -240,7 +240,7 @@ So, the big "take-away" from the above table is that you need to understand the
### SceneEventType Specific Notifications
There might be a time where you aren't interested in all of the details for each scene event type that occurs. As it just so happens, `NetworkSceneManager` includes a single delegate handler for each `SceneEventType` that is only triggered for the associated `SceneEventType`.
-You can explore the [NetworkSceneManager](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.SceneEventType.html) for a full listing of the corresponding single `SceneEventType` events.
+You can explore the [NetworkSceneManager](xref:Unity.Netcode.SceneEventType) for a full listing of the corresponding single `SceneEventType` events.
Some examples:
- NetworkSceneManager.OnLoad: Triggered when for `OnLoad` scene events.
- NetworkSceneManager.OnUnload: Triggered when for `OnUnload` scene events.
diff --git a/com.unity.netcode.gameobjects/Documentation~/basics/scenemanagement/using-networkscenemanager.md b/com.unity.netcode.gameobjects/Documentation~/basics/scenemanagement/using-networkscenemanager.md
index 5837249132..ac54460414 100644
--- a/com.unity.netcode.gameobjects/Documentation~/basics/scenemanagement/using-networkscenemanager.md
+++ b/com.unity.netcode.gameobjects/Documentation~/basics/scenemanagement/using-networkscenemanager.md
@@ -19,7 +19,7 @@
> [!NOTE]
> In-Scene placed NetworkObjects can be used in many ways and are treated uniquely from that of dynamically spawned NetworkObjects. An in-scene placed NetworkObject is a GameObject with a NetworkObject and typically at least one NetworkBehaviour component attached to a child of or the same GameObject. it's recommended to read through all integrated scene management materials (this document, [Scene Events](scene-events.md), and [Timing Considerations](timing-considerations.md)) before learning about more advanced [In-Scene (placed) NetworkObjects](inscene-placed-networkobjects.md) topics.
-All of these scene management features (and more) are handled by the [`NetworkSceneManager`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkSceneManager.html).
+All of these scene management features (and more) are handled by the [`NetworkSceneManager`](xref:Unity.Netcode.NetworkSceneManager).
### Accessing `NetworkSceneManager`
The `NetworkSceneManager` lives within the NetworkManager and is instantiated when the NetworkManager is started.
@@ -122,7 +122,7 @@ The purpose behind the above outline is to show that a Scene Event can lead to o
#### Scene Event Notifications
You can be notified of scene events by registering in one of two ways:
1. Receive all scene event notification types: `NetworkSceneManager.OnSceneEvent`
-2. Receive only a specific scene event notification type: [`NetworkSceneManager`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkSceneManager.html#events) has one for each [`SceneEventType`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.SceneEventType.html)
+2. Receive only a specific scene event notification type: [`NetworkSceneManager`](xref:Unity.Netcode.NetworkSceneManager) has one for each [`SceneEventType`](xref:Unity.Netcode.SceneEventType)
> [!NOTE]
> Receiving (via subscribing to the associated event callback) only specific scene event notification types does not change how a server or client receives and processes notifications.
@@ -137,7 +137,7 @@ Typically, this is used with clients or components that might only need to be no
You might want to register for the `SceneEventType.LoadEventCompleted` scene event type to know, from a client perspective, that the server and all other clients have finished loading a scene. This notification lets you know when you can start performing other netcode related actions on the newly loaded and spawned NetworkObjects.
#### Scene Event Progress Status
-As we discussed in the earlier code example, it's important to check the status returned by `NetworkSceneManager.Load` to make sure your scene loading event has started. The following is a list of all [SceneEventProgressStatus](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.SceneEventProgressStatus.html) `enum` values with some additional helpful information:
+As we discussed in the earlier code example, it's important to check the status returned by `NetworkSceneManager.Load` to make sure your scene loading event has started. The following is a list of all [SceneEventProgressStatus](xref:Unity.Netcode.SceneEventProgressStatus) `enum` values with some additional helpful information:
- Started
- The scene event has started (success)
- SceneNotLoaded
diff --git a/com.unity.netcode.gameobjects/Documentation~/components/core/corecomponents.md b/com.unity.netcode.gameobjects/Documentation~/components/core/corecomponents.md
index 8c4c49d2d8..b07a4113cf 100644
--- a/com.unity.netcode.gameobjects/Documentation~/components/core/corecomponents.md
+++ b/com.unity.netcode.gameobjects/Documentation~/components/core/corecomponents.md
@@ -20,7 +20,7 @@ Learn about the three core components of Netcode for GameObjects: NetworkObject,
| **Topic** | **Description** |
| :------------------------------ | :------------------------------- |
-| **[NetworkBehaviour](networkbehaviour.md)** | [NetworkBehaviour](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkBehaviour.html) is an abstract class that derives from [MonoBehaviour](https://docs.unity3d.com/ScriptReference/MonoBehaviour.html) and is primarily used to create unique netcode or game logic. To replicate any netcode-aware properties or send and receive RPCs, a [GameObject](https://docs.unity3d.com/Manual/GameObjects.html) must have a [NetworkObject](networkobject.md) component and at least one NetworkBehaviour component. |
+| **[NetworkBehaviour](networkbehaviour.md)** | [NetworkBehaviour](xref:Unity.Netcode.NetworkBehaviour) is an abstract class that derives from [MonoBehaviour](https://docs.unity3d.com/ScriptReference/MonoBehaviour.html) and is primarily used to create unique netcode or game logic. To replicate any netcode-aware properties or send and receive RPCs, a [GameObject](https://docs.unity3d.com/Manual/GameObjects.html) must have a [NetworkObject](networkobject.md) component and at least one NetworkBehaviour component. |
| **[Synchronizing](networkbehaviour-synchronize.md)** | Understand a NetworkBehaviour component's order of operations when it comes to spawning, despawning, and adding custom synchronization data. |
diff --git a/com.unity.netcode.gameobjects/Documentation~/components/core/networkbehaviour-ownership.md b/com.unity.netcode.gameobjects/Documentation~/components/core/networkbehaviour-ownership.md
index 3511fd44f8..fee658cd12 100644
--- a/com.unity.netcode.gameobjects/Documentation~/components/core/networkbehaviour-ownership.md
+++ b/com.unity.netcode.gameobjects/Documentation~/components/core/networkbehaviour-ownership.md
@@ -1,25 +1,25 @@
# NetworkBehaviour ownership
-Before reading these docs, ensure you understand the concepts of [ownership](../terms-concepts/ownership.md) and [NetworkObject ownership](./networkobject-ownership.md). It's also important to be familiar with the [NetworkBehaviour](./networkbehaviour.md)
+Before reading these docs, ensure you understand the concepts of [ownership](../../terms-concepts/ownership.md) and [NetworkObject ownership](./networkobject-ownership.md). It's also important to be familiar with the [NetworkBehaviour](./networkbehaviour.md)
-The owner of each NetworkBehaviour in your game is decided by the owner of that NetworkBehaviour's NetworkObject. The NetworkObject is found as a property on the NetworkBehaviour: [`NetworkBehaviour.NetworkObject`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkBehaviour.html#Unity_Netcode_NetworkBehaviour_NetworkObject).
+The owner of each NetworkBehaviour in your game is decided by the owner of that NetworkBehaviour's NetworkObject. The NetworkObject is found as a property on the NetworkBehaviour: [`NetworkBehaviour.NetworkObject`](xref:Unity.Netcode.NetworkBehaviour.NetworkObject).
## Helpful properties
> [!NOTE]
-> The following properties are only valid if the NetworkBehaviour has been spawned. Use [`NetworkBehaviour.IsSpawned`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkBehaviour.html#Unity_Netcode_NetworkBehaviour_IsSpawned) to check the spawned status of the NetworkBehaviour
+> The following properties are only valid if the NetworkBehaviour has been spawned. Use [`NetworkBehaviour.IsSpawned`](xref:Unity.Netcode.NetworkBehaviour.IsSpawned) to check the spawned status of the NetworkBehaviour
-To identify whether the local client is the owner of a NetworkBehaviour, you can check the[`NetworkBehaviour.IsOwner`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkBehaviour.html#Unity_Netcode_NetworkBehaviour_IsOwner) property.
+To identify whether the local client is the owner of a NetworkBehaviour, you can check the[`NetworkBehaviour.IsOwner`](xref:Unity.Netcode.NetworkBehaviour.IsOwner) property.
-To identify whether the server owns a NetworkBehaviour, you can check the [`NetworkBehaviour.IsOwnedByServer`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkBehaviour.html#Unity_Netcode_NetworkBehaviour_IsOwnedByServer) property.
+To identify whether the server owns a NetworkBehaviour, you can check the [`NetworkBehaviour.IsOwnedByServer`](xref:Unity.Netcode.NetworkBehaviour.IsOwnedByServer) property.
-To identify whether the local client has authority of a NetworkBehaviour, you can check the[`NetworkBehaviour.HasAuthority`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkBehaviour.html#Unity_Netcode_NetworkBehaviour_HasAuthority) property.
+To identify whether the local client has authority of a NetworkBehaviour, you can check the[`NetworkBehaviour.HasAuthority`](xref:Unity.Netcode.NetworkBehaviour.HasAuthority) property.
## Detecting ownership changes
There are three functions that can be implemented to detect ownership changes on a NetworkBehaviour. These functions are invoked in the order they are listed here.
-### [OnLostOwnership](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkBehaviour.html#Unity_Netcode_NetworkBehaviour_OnLostOwnership)
+### [OnLostOwnership](xref:Unity.Netcode.NetworkBehaviour.OnLostOwnership)
When using a [client-server network topology](../../terms-concepts/client-server.md) `OnLostOwnership` is invoked on both the server any time a connected client loses ownership of this NetworkBehaviour. It is also invoked on the game client who just lost ownership.
@@ -34,7 +34,7 @@ void OnLostOwnership()
}
```
-### [OnGainedOwnership](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkBehaviour.html#Unity_Netcode_NetworkBehaviour_OnGainedOwnership)
+### [OnGainedOwnership](xref:Unity.Netcode.NetworkBehaviour.OnGainedOwnership)
When using a client-server network topology `OnGainedOwnership` is invoked on the server any time ownership is gained. It is also be invoked on the game client who just gained ownership.
@@ -52,7 +52,7 @@ void OnGainedOwnership()
}
```
-### [OnOwnershipChanged](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkBehaviour.html#Unity_Netcode_NetworkBehaviour_OnOwnershipChanged_System_UInt64_System_UInt64_)
+### [OnOwnershipChanged](xref:Unity.Netcode.NetworkBehaviour.OnOwnershipChanged*)
Whenever you want notification on any and all ownership changes, implement the `OnOwnershipChanged` method. `OnOwnershipChanged` is invoked on all connected game clients whenever the ownership of the NetworkBehaviour it is implemented on changes.
diff --git a/com.unity.netcode.gameobjects/Documentation~/components/core/networkbehaviour-synchronize.md b/com.unity.netcode.gameobjects/Documentation~/components/core/networkbehaviour-synchronize.md
index 166b69c4bc..e273296ea5 100644
--- a/com.unity.netcode.gameobjects/Documentation~/components/core/networkbehaviour-synchronize.md
+++ b/com.unity.netcode.gameobjects/Documentation~/components/core/networkbehaviour-synchronize.md
@@ -1,6 +1,6 @@
# NetworkBehaviour synchronization
-[NetworkBehaviour](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkBehaviour.html) is an abstract class that derives from [MonoBehaviour](https://docs.unity3d.com/ScriptReference/MonoBehaviour.html) and is primarily used to create unique netcode or game logic. To replicate any netcode-aware properties or send and receive RPCs, a [GameObject](https://docs.unity3d.com/Manual/GameObjects.html) must have a [NetworkObject](networkobject.md) component and at least one NetworkBehaviour component.
+[NetworkBehaviour](xref:Unity.Netcode.NetworkBehaviour) is an abstract class that derives from [MonoBehaviour](https://docs.unity3d.com/ScriptReference/MonoBehaviour.html) and is primarily used to create unique netcode or game logic. To replicate any netcode-aware properties or send and receive RPCs, a [GameObject](https://docs.unity3d.com/Manual/GameObjects.html) must have a [NetworkObject](networkobject.md) component and at least one NetworkBehaviour component.
You can use NetworkBehaviours to synchronize settings before, during, and after spawning NetworkObjects.
@@ -238,4 +238,4 @@ However, there is an additional check to assure that the total expected bytes to
## Serializing NetworkBehaviours
-NetworkBehaviours require the use of specialized [`NetworkBehaviourReference`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkBehaviourReference.html) structures to be serialized and used with RPCs and `NetworkVariable`s.
+NetworkBehaviours require the use of specialized [`NetworkBehaviourReference`](xref:Unity.Netcode.NetworkBehaviourReference) structures to be serialized and used with RPCs and `NetworkVariable`s.
diff --git a/com.unity.netcode.gameobjects/Documentation~/components/core/networkbehaviour.md b/com.unity.netcode.gameobjects/Documentation~/components/core/networkbehaviour.md
index 0922a6d35a..4b1f7e0b02 100644
--- a/com.unity.netcode.gameobjects/Documentation~/components/core/networkbehaviour.md
+++ b/com.unity.netcode.gameobjects/Documentation~/components/core/networkbehaviour.md
@@ -1,6 +1,6 @@
# NetworkBehaviour
-[NetworkBehaviour](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkBehaviour.html) is an abstract class that derives from [MonoBehaviour](https://docs.unity3d.com/ScriptReference/MonoBehaviour.html) and is primarily used to create unique netcode or game logic. To replicate any netcode-aware properties or send and receive RPCs, a [GameObject](https://docs.unity3d.com/Manual/GameObjects.html) must have a [NetworkObject](networkobject.md) component and at least one NetworkBehaviour component.
+[NetworkBehaviour](xref:Unity.Netcode.NetworkBehaviour) is an abstract class that derives from [MonoBehaviour](https://docs.unity3d.com/ScriptReference/MonoBehaviour.html) and is primarily used to create unique netcode or game logic. To replicate any netcode-aware properties or send and receive RPCs, a [GameObject](https://docs.unity3d.com/Manual/GameObjects.html) must have a [NetworkObject](networkobject.md) component and at least one NetworkBehaviour component.
A NetworkBehaviour requires a NetworkObject component on the same relative GameObject or on a parent of the GameObject with the NetworkBehaviour component assigned to it. If you add a NetworkBehaviour to a GameObject that doesn't have a NetworkObject (or any parent), then Netcode for GameObjects automatically adds a NetworkObject component to the GameObject in which the NetworkBehaviour was added.
diff --git a/com.unity.netcode.gameobjects/Documentation~/components/core/networkmanager.md b/com.unity.netcode.gameobjects/Documentation~/components/core/networkmanager.md
index aa59d87d89..7cd646a6ce 100644
--- a/com.unity.netcode.gameobjects/Documentation~/components/core/networkmanager.md
+++ b/com.unity.netcode.gameobjects/Documentation~/components/core/networkmanager.md
@@ -5,7 +5,7 @@ The NetworkManager is a required Netcode for GameObjects component that has all
## NetworkManager Inspector properties
- **LogLevel**: Sets the network logging level
-- **PlayerPrefab**: When a Prefab is assigned, the Prefab will be instantiated as the player object. For more information about player prefabs, refer to [Player NetworkObjects](networkobject.md#player-networkobjects).
+- **PlayerPrefab**: When a Prefab is assigned, the Prefab will be instantiated as the player object. For more information about player prefabs, refer to [Player NetworkObjects](playerobjects.md).
- **NetworkPrefabs**: Where you register your network prefabs. You can also create a single network Prefab override per registered network Prefab here.
- **Protocol Version**: Set this value to help distinguish between builds when the most current build has new assets that can cause issues with older builds connecting.
- **Network Transport**: Where your network specific settings and transport type is set. When using a [client-server topology](../../terms-concepts/client-server.md), This field accepts any INetworkTransport implementation. However, unless you have unique transport specific needs UnityTransport is the recommended transport to use with Netcode for GameObjects. For a [distributed authority topology](../../terms-concepts/distributed-authority.md), refer to the [distributed authority quickstart](../../learn/distributed-authority-quick-start.md).
@@ -19,6 +19,15 @@ The NetworkManager is a required Netcode for GameObjects component that has all
- **Enable Scene Management**: When checked, Netcode for GameObjects will handle scene management and client synchronization for you. When not checked, you will have to create your own scene management scripts and handle client synchronization.
- **Load Scene Time Out**: When Enable Scene Management is checked, this specifies the period of time the `NetworkSceneManager` will wait while a scene is being loaded asynchronously before `NetworkSceneManager` considers the load/unload scene event to have failed/timed out.
+### Distributed authority network topology
+
+> [!NOTE]
+> The distributed authority network topology requires Multiplayer Services. If the Multiplayer Services package is not installed, the **Network Topology** property will not be displayed.
+
+- **Network Topology**: Defines the network topology to use.
+ - **Client-Server**: Selects the client-server network topology.
+ - **Distributed authority**: Selects the distributed authority network topology.
+
## NetworkManager sub-systems
NetworkManager is also where you can find references to other Netcode related management systems:
@@ -68,7 +77,7 @@ NetworkManager.Singleton.StartClient();
When starting a Server or joining an already started session as client, the NetworkManager can spawn a "Player Object" belonging to the client. For more information about player prefabs, refer to:
- [NetworkObject Player Prefab Documentation](networkobject.md)
- - [Connection Approval](../../basics/connection-approval)
+ - [Connection Approval](../../basics/connection-approval.md)
## Connecting
@@ -135,7 +144,7 @@ The server-host attempts to wait for all client connections to close before it f
At times you might need to disconnect a client for various reasons without shutting down the server. To do this, you can call the `NetworkManager.DisconnectClient` method while passing the identifier of the client you wish to disconnect as the only parameter. The client identifier can be found within:
-- The `NetworkManager.ConnectedClients` dictionary that uses the client identifier as a key and the value as the [`NetworkClient`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkClient.html).
+- The `NetworkManager.ConnectedClients` dictionary that uses the client identifier as a key and the value as the [`NetworkClient`](xref:Unity.Netcode.NetworkClient).
- As a read only list of `NetworkClients` via the `NetworkManager.ConnectedClientsList`.
- A full list of all connected client identifiers can be accessed via `NetworkManager.ConnectedClientsIds`.
- The client identifier is passed as a parameter to all subscribers of the `NetworkManager.OnClientConnected` event.
@@ -261,16 +270,16 @@ public class ConnectionNotificationManager : MonoBehaviour
There are two static NetworkManager events you can use to be notified when a NetworkManager is instantiated or is about to be destroyed:
-- [`NetworkManager.OnInstantiated`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkManager.html#Unity_Netcode_NetworkManager_OnInstantiated): This is invoked when a NetworkManager is instantiated.
-- [`NetworkManager.OnDestroying`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkManager.html#Unity_Netcode_NetworkManager_OnDestroying): This is invoked when a NetworkManager is about to be destroyed.
+- [`NetworkManager.OnInstantiated`](xref:Unity.Netcode.NetworkManager.OnInstantiated): This is invoked when a NetworkManager is instantiated.
+- [`NetworkManager.OnDestroying`](xref:Unity.Netcode.NetworkManager.OnDestroying): This is invoked when a NetworkManager is about to be destroyed.
### When a NetworkManager is stopped
Knowing when a NetworkManager has stopped is useful for establishing when it's safe to transition back to a main menu scene, or other similar tasks. There are two events you can use to be notified that the NetworkManager has finished shutting down:
-- [`NetworkManager.OnClientStopped`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkManager.html#Unity_Netcode_NetworkManager_OnClientStopped): This is invoked on a host or client when the NetworkManager has completely shut down and is ready to be restarted.
-- [`NetworkManager.OnServerStopped`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkManager.html#Unity_Netcode_NetworkManager_OnServerStopped): This is invoked on a host or server when the NetworkManager has completely shut down and is ready to be restarted.
+- [`NetworkManager.OnClientStopped`](xref:Unity.Netcode.NetworkManager.OnClientStopped): This is invoked on a host or client when the NetworkManager has completely shut down and is ready to be restarted.
+- [`NetworkManager.OnServerStopped`](xref:Unity.Netcode.NetworkManager.OnServerStopped): This is invoked on a host or server when the NetworkManager has completely shut down and is ready to be restarted.
Since a host is both a client and a server, the event invocation order is:
@@ -283,4 +292,4 @@ Since a host is both a client and a server, the event invocation order is:
If you need to save the state of spawned objects before they're destroyed when the NetworkManager shuts down, you can use the following event notification:
-- [`NetworkManager.OnPreShutdown`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkManager.html#Unity_Netcode_NetworkManager_OnPreShutdown): This is invoked prior to finalizing the NetworkManager shut down process. Any remaining spawned objects will still be instantiated and spawned when this event is invoked.
+- [`NetworkManager.OnPreShutdown`](xref:Unity.Netcode.NetworkManager.OnPreShutdown): This is invoked prior to finalizing the NetworkManager shut down process. Any remaining spawned objects will still be instantiated and spawned when this event is invoked.
diff --git a/com.unity.netcode.gameobjects/Documentation~/components/core/networkobject-ownership.md b/com.unity.netcode.gameobjects/Documentation~/components/core/networkobject-ownership.md
index 81bad2dfff..f2975393e6 100644
--- a/com.unity.netcode.gameobjects/Documentation~/components/core/networkobject-ownership.md
+++ b/com.unity.netcode.gameobjects/Documentation~/components/core/networkobject-ownership.md
@@ -9,11 +9,11 @@ Read more about how to detect when ownership has changed in [NetworkBehaviour ow
## Helpful properties
> [!NOTE]
-> All NetworkObject properties are only valid while the NetworkObject is spawned. Use [`NetworkObject.IsSpawned`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkObject.html#Unity_Netcode_NetworkObject_IsSpawned) to check the spawned status of the NetworkObject.
+> All NetworkObject properties are only valid while the NetworkObject is spawned. Use [`NetworkObject.IsSpawned`](xref:Unity.Netcode.NetworkObject.IsSpawned) to check the spawned status of the NetworkObject.
-To identify whether the local client is the owner of a NetworkObject, you can check the[`NetworkObject.IsOwner`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkObject.IsOwner.html) or the [`NetworkBehaviour.IsOwner`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkBehaviour.IsOwner.html) property.
+To identify whether the local client is the owner of a NetworkObject, you can check the[`NetworkObject.IsOwner`](xref:Unity.Netcode.NetworkObject.IsOwner) or the [`NetworkBehaviour.IsOwner`](xref:Unity.Netcode.NetworkBehaviour.IsOwner) property.
-To identify whether the server owns a NetworkObject, you can check the [`NetworkObject.IsOwnedByServer`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkObject.IsOwnedByServer.html) or the [`NetworkBehaviour.IsOwnedByServer`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkBehaviour.IsOwnedByServer.html) property.
+To identify whether the server owns a NetworkObject, you can check the [`NetworkObject.IsOwnedByServer`](xref:Unity.Netcode.NetworkObject.IsOwnedByServer) or the [`NetworkBehaviour.IsOwnedByServer`](xref:Unity.Netcode.NetworkBehaviour.IsOwnedByServer) property.
> [!NOTE]
> To assure a spawned NetworkObject persists after the owner leaves a session, set the `NetworkObject.DontDestroyWithOwner` property to true. This assures the client-owned NetworkObject doesn't get destroyed when the owning client leaves.
@@ -39,7 +39,7 @@ NetworkObject.SpawnWithOwnership(clientId);
> [!NOTE]
> Using `SpawnWithOwnership` can result in unexpected behavior when the spawning game client makes any other changes on the object immediately after spawning.
-Using `SpawnWithOwnership` and then editing the NetworkObject locally means that the client doing the spawning will behave as the spawn authority. The spawn authority has limited local [authority](../terms-concepts/authority.md) over the NetworkObject, but not [ownership](../terms-concepts/ownership.md) of the NetworkObject that's spawned. This means any owner-specific checks during the spawn sequence will not be invoked on the spawn authority side.
+Using `SpawnWithOwnership` and then editing the NetworkObject locally means that the client doing the spawning will behave as the spawn authority. The spawn authority has limited local [authority](../../terms-concepts/authority.md) over the NetworkObject, but not [ownership](../../terms-concepts/ownership.md) of the NetworkObject that's spawned. This means any owner-specific checks during the spawn sequence will not be invoked on the spawn authority side.
If you want to spawn a NetworkObject for another client and then immediately make adjustments to that NetworkObject, it's recommended to use the `Spawn` method. After adjusting, the spawn authority can immediately follow with a call to `ChangeOwnership`.
@@ -111,15 +111,18 @@ The authority of any NetworkObject can always change ownership, as outlined in [
### Ownership permission settings
-The following ownership permission settings, defined by [`NetworkObject.OwnershipStatus`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkObject.OwnershipStatus.html), control how ownership of NetworkObjects can be changed during a distributed authority session:
+> [!NOTE]
+> Permissions are only valid when using the distributed authority network topology, which requires Multiplayer Services. If the Multiplayer Services package is not installed, the permissions setting will not be displayed.
+
+The following ownership permission settings, defined by [`NetworkObject.OwnershipStatus`](xref:Unity.Netcode.NetworkObject.OwnershipStatus), control how ownership of NetworkObjects can be changed during a distributed authority session:
|**Ownership setting**|Description|Related Property|Multi-select|
|-----|-----|-----|-----|
|`None`|Ownership of this NetworkObject can't be redistributed, requested, or transferred (a Player might have this, for example).||No|
-|`Distributable`|Ownership of this NetworkObject is automatically redistributed when a client joins or leaves, as long as ownership is not locked or a request is pending.|[`IsOwnershipDistributable`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkObject.html#Unity_Netcode_NetworkObject_IsOwnershipDistributable)|**Yes**|
-|`Transferable`|Any client can change ownership of this NetworkObject at any time, as long as ownership is not locked or a request is pending.|[`IsOwnershipTransferable`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkObject.html#Unity_Netcode_NetworkObject_IsOwnershipTransferable)|**Yes**|
-|`RequestRequired`|Ownership of this NetworkObject must be requested before ownership can be changed.|[`IsOwnershipRequestRequired`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkObject.html#Unity_Netcode_NetworkObject_IsOwnershipRequestRequired), [`IsRequestInProgress`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkObject.html#Unity_Netcode_NetworkObject_IsRequestInProgress)|**Yes**|
-|`SessionOwner`|This NetworkObject is always owned by the [session owner](distributed-authority.md#session-ownership) and can't be transferred or distributed. If the session owner changes, this NetworkObject is automatically transferred to the new session owner.|[`IsOwnershipSessionOwner`](Unity_Netcode_NetworkObject_IsOwnershipSessionOwner)|No|
+|`Distributable`|Ownership of this NetworkObject is automatically redistributed when a client joins or leaves, as long as ownership is not locked or a request is pending.|[`IsOwnershipDistributable`](xref:Unity.Netcode.NetworkObject.IsOwnershipDistributable)|**Yes**|
+|`Transferable`|Any client can change ownership of this NetworkObject at any time, as long as ownership is not locked or a request is pending.|[`IsOwnershipTransferable`](xref:Unity.Netcode.NetworkObject.IsOwnershipTransferable)|**Yes**|
+|`RequestRequired`|Ownership of this NetworkObject must be requested before ownership can be changed.|[`IsOwnershipRequestRequired`](xref:Unity.Netcode.NetworkObject.IsOwnershipRequestRequired), [`IsRequestInProgress`](xref:Unity.Netcode.NetworkObject.IsRequestInProgress)|**Yes**|
+|`SessionOwner`|This NetworkObject is always owned by the [session owner](../../terms-concepts/distributed-authority.md#session-ownership) and can't be transferred or distributed. If the session owner changes, this NetworkObject is automatically transferred to the new session owner.|[`IsOwnershipSessionOwner`](xref:Unity.Netcode.NetworkObject.IsOwnershipSessionOwner)|No|
Ownership permissions can be set in the editor using the **Ownership** dropdown.
@@ -127,7 +130,7 @@ Ownership permissions can be set in the editor using the **Ownership** dropdown.
They can also be set in script using
-You can also use `NetworkObject.SetOwnershipLock` to lock and unlock the permission settings of a NetworkObject for a period of time, preventing ownership changes on a temporary basis. The [`IsOwnershipLocked`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkObject.html#Unity_Netcode_NetworkObject_IsOwnershipLocked) property can be used to detect if an object has locked ownership.
+You can also use `NetworkObject.SetOwnershipLock` to lock and unlock the permission settings of a NetworkObject for a period of time, preventing ownership changes on a temporary basis. The [`IsOwnershipLocked`](xref:Unity.Netcode.NetworkObject.IsOwnershipLocked) property can be used to detect if an object has locked ownership.
```csharp
// To lock an object from any ownership changes
@@ -148,7 +151,7 @@ NetworkObject.ChangeOwnership(clientId);
NetworkObject.ChangeOwnership(NetworkManager.LocalClientId);
```
-When a non-authoritative game client calls `ChangeOwnership`, the ownership change can fail. On a failed attempt to change ownership, the `OnOwnershipPermissionsFailure` callback will be invoked with a [`NetworkObject.OwnershipPermissionsFailureStatus`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkObject.OwnershipPermissionsFailureStatus.html) to give information on the failure.
+When a non-authoritative game client calls `ChangeOwnership`, the ownership change can fail. On a failed attempt to change ownership, the `OnOwnershipPermissionsFailure` callback will be invoked with a [`NetworkObject.OwnershipPermissionsFailureStatus`](xref:Unity.Netcode.NetworkObject.OwnershipPermissionsFailureStatus) to give information on the failure.
```csharp
/*
@@ -200,9 +203,9 @@ When a NetworkObject is set with `OwnershipPermissions.RequestRequired` any clie
var requestStatus = NetworkObject.RequestOwnership();
```
-`RequestOwnership` returns an [`OwnershipRequestStatus`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkObject.OwnershipRequestStatus.html) to indicate the initial status of the request. To view the result of the request, the `OnOwnershipRequestResponse` callback will be invoked with a [`NetworkObject.OwnershipRequestResponseStatus`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkObject.OwnershipRequestResponseStatus.html).
+`RequestOwnership` returns an [`OwnershipRequestStatus`](xref:Unity.Netcode.NetworkObject.OwnershipRequestStatus) to indicate the initial status of the request. To view the result of the request, the `OnOwnershipRequestResponse` callback will be invoked with a [`NetworkObject.OwnershipRequestResponseStatus`](xref:Unity.Netcode.NetworkObject.OwnershipRequestResponseStatus).
-By default, any requests for ownership will automatically be approved. To control which client is approved for ownership, use the [`OnOwnershipRequested`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkObject.html#Unity_Netcode_NetworkObject_OnOwnershipRequested) callback
+By default, any requests for ownership will automatically be approved. To control which client is approved for ownership, use the [`OnOwnershipRequested`](xref:Unity.Netcode.NetworkObject.OnOwnershipRequested) callback
```csharp
/*
@@ -264,8 +267,8 @@ public class RequestableOwnershipBehaviour : NetworkBehaviour
## Additional resources
-- [NetworkObject](../components/core/networkobject.md)
+- [NetworkObject](./networkobject.md)
- [NetworkBehaviour](./networkbehaviour.md)
- [NetworkBehaviour ownership](./networkbehaviour-ownership.md)
-- [Ownership](../terms-concepts/ownership.md)
-- [Authority](../terms-concepts/authority.md)
+- [Ownership](../../terms-concepts/ownership.md)
+- [Authority](../../terms-concepts/authority.md)
diff --git a/com.unity.netcode.gameobjects/Documentation~/components/core/networkobject.md b/com.unity.netcode.gameobjects/Documentation~/components/core/networkobject.md
index 56730e4c71..495bed2691 100644
--- a/com.unity.netcode.gameobjects/Documentation~/components/core/networkobject.md
+++ b/com.unity.netcode.gameobjects/Documentation~/components/core/networkobject.md
@@ -7,7 +7,7 @@ Netcode for GameObjects' high level components, [the RPC system](../../advanced-
1. NetworkObject
2. [NetworkBehaviour](networkbehaviour.md)
-NetworkObjects require the use of specialized [`NetworkObjectReference`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkObjectReference.html) structures before you can serialize and use them with RPCs and `NetworkVariable`s
+NetworkObjects require the use of specialized [`NetworkObjectReference`](xref:Unity.Netcode.NetworkObjectReference) structures before you can serialize and use them with RPCs and `NetworkVariable`s
Netcode for GameObjects also has [PlayerObjects](playerobjects.md), an optional feature that you can use to assign a NetworkObject to a specific client.
@@ -19,6 +19,32 @@ When spawning a NetworkObject, the `NetworkObject.GlobalObjectIdHash` value init
You can use [NetworkBehaviours](networkbehaviour.md) to add your own custom Netcode logic to the associated NetworkObject.
+### What is a valid NetworkObject?
+
+There are two categories of NetworkObjects:
+* Dynamically instantiated
+* [In-scene placed](../../basics/scenemanagement/inscene-placed-networkobjects.md)
+
+The following provides the validity requirements for both types.
+
+#### Dynamically instantiated network prefabs
+
+Dynamically instantiated network prefabs must:
+
+* Be a valid [network prefab](./networkobject.md#network-prefabs) created within the Editor.
+* Be registered in a network prefab list that's assigned to your NetworkManager.
+
+#### In-scene placed network prefabs
+
+In-scene placed network prefabs must:
+
+* Be a valid network prefab instance within a scene.
+* Be a GameObject with a NetworkObject component created within the scene while in the Editor.
+
+### What is an invalid NetworkObject?
+
+GameObjects that have NetworkObject components added to them during runtime are **not supported** and will result in the NetworkObject's `GlobalObjectIdHash` being zero, which causes synchronization issues. In the event you make this mistake, a warning message will be logged and the NetworkObject won't be spawned.
+
### Component order
The order of components on a networked GameObject matters. When adding netcode components to a GameObject, ensure that the NetworkObject component is ordered before any NetworkBehaviour components.
@@ -65,7 +91,7 @@ Refer to the [NetworkSceneManager active scene synchronization](../../basics/sce
-Similar to [`NetworkObject.ActiveSceneSynchronization`](#active-scene-synchronization), [`NetworkObject.SceneMigrationSynchronization`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkObject.html#Unity_Netcode_NetworkObject_SceneMigrationSynchronization) automatically synchronizes client-side NetworkObject instances that are migrated to a scene via [`SceneManager.MoveGameObjectToScene`](https://docs.unity3d.com/ScriptReference/SceneManagement.SceneManager.MoveGameObjectToScene.html) on the host or server side. This can be useful if you have a specific scene you wish to migrate NetworkObject instances to that is not the currently active scene.
+Similar to [`NetworkObject.ActiveSceneSynchronization`](#active-scene-synchronization), [`NetworkObject.SceneMigrationSynchronization`](xref:Unity.Netcode.NetworkObject.SceneMigrationSynchronization) automatically synchronizes client-side NetworkObject instances that are migrated to a scene via [`SceneManager.MoveGameObjectToScene`](https://docs.unity3d.com/ScriptReference/SceneManagement.SceneManager.MoveGameObjectToScene.html) on the host or server side. This can be useful if you have a specific scene you wish to migrate NetworkObject instances to that is not the currently active scene.
`NetworkObject.ActiveSceneSynchronization` can be used with `NetworkObject.SceneMigrationSynchronization` as long as you take into consideration that if you migrate a NetworkObject into a non-active scene via `SceneManager.MoveGameObjectToScene` and later change the active scene, then the NetworkObject instance will be automatically migrated to the newly set active scene.
diff --git a/com.unity.netcode.gameobjects/Documentation~/components/core/playerobjects.md b/com.unity.netcode.gameobjects/Documentation~/components/core/playerobjects.md
index e7ae88353f..a679806c44 100644
--- a/com.unity.netcode.gameobjects/Documentation~/components/core/playerobjects.md
+++ b/com.unity.netcode.gameobjects/Documentation~/components/core/playerobjects.md
@@ -53,14 +53,14 @@ In addition to the [session-mode agnostic spawning methods](#session-mode-agnost
### Distributed authority contexts only
-In addition to the [session-mode agnostic spawning methods](#session-mode-agnostic-methods) above, you can use the [`OnFetchLocalPlayerPrefabToSpawn`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkManager.html#Unity_Netcode_NetworkManager_OnFetchLocalPlayerPrefabToSpawn) method to assign a unique player prefab on a per-client basis when in [distributed authority contexts](../../terms-concepts/distributed-authority.md).
+In addition to the [session-mode agnostic spawning methods](#session-mode-agnostic-methods) above, you can use the [`OnFetchLocalPlayerPrefabToSpawn`](xref:Unity.Netcode.NetworkManager.OnFetchLocalPlayerPrefabToSpawn) method to assign a unique player prefab on a per-client basis when in [distributed authority contexts](../../terms-concepts/distributed-authority.md).
To use `OnFetchLocalPlayerPrefabToSpawn` in your project, assign a callback handler to `OnFetchLocalPlayerPrefabToSpawn` and whatever the client script returns is what will be spawned for that client. Ensure that the prefab being spawned is in a NetworkPrefabList [registered with the NetworkManager](../../basics/object-spawning.md#registering-a-network-prefab).
If you don't assign a callback handler to `OnFetchLocalPlayerPrefabToSpawn`, then the default behavior is to return the `NetworkConfig.PlayerPrefab` (or null if neither are set).
:::note `AutoSpawnPlayerPrefabClientSide` required
-For `OnFetchLocalPlayerPrefabToSpawn` to work, [`AutoSpawnPlayerPrefabClientSide`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkManager.html#Unity_Netcode_NetworkManager_AutoSpawnPlayerPrefabClientSide) must be enabled.
+For `OnFetchLocalPlayerPrefabToSpawn` to work, [`AutoSpawnPlayerPrefabClientSide`](xref:Unity.Netcode.NetworkManager.AutoSpawnPlayerPrefabClientSide) must be enabled.
:::
## PlayerObject spawning timeline
diff --git a/com.unity.netcode.gameobjects/Documentation~/components/helper/componentcontroller.md b/com.unity.netcode.gameobjects/Documentation~/components/helper/componentcontroller.md
index 26465b9d6e..09136b095e 100644
--- a/com.unity.netcode.gameobjects/Documentation~/components/helper/componentcontroller.md
+++ b/com.unity.netcode.gameobjects/Documentation~/components/helper/componentcontroller.md
@@ -1,6 +1,6 @@
# ComponentController
-Use a [ComponentController](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.ComponentController.html) component to enable or disable one or more components depending on the authority state of the ComponentController and have those changes synchronized with non-authority instances.
+Use a [ComponentController](xref:Unity.Netcode.ComponentController) component to enable or disable one or more components depending on the authority state of the ComponentController and have those changes synchronized with non-authority instances.
For example, you can use a ComponentController to enable or disable a MeshRenderer component on the owner of the ComponentController instance, while disabling it for all other clients. This is useful for controlling visibility of objects that should only be visible to the owner, such as a player's avatar or a weapon they are holding.
diff --git a/com.unity.netcode.gameobjects/Documentation~/components/helper/helpercomponents.md b/com.unity.netcode.gameobjects/Documentation~/components/helper/helpercomponents.md
index 64df3f347b..d9515ebb47 100644
--- a/com.unity.netcode.gameobjects/Documentation~/components/helper/helpercomponents.md
+++ b/com.unity.netcode.gameobjects/Documentation~/components/helper/helpercomponents.md
@@ -6,8 +6,8 @@ Understand the helper components available to use in your Netcode for GameObject
| :------------------------------ | :------------------------------- |
| **[AttachableBehaviour](attachablebehaviour.md)**| Use the AttachableBehaviour component to manage [ComponentController](componentcontroller.md) components and to attach a child GameObject to an [AttachableNode](attachablenode.md). The AttachableBehaviour component provides an alternative to NetworkObject parenting, allowing you to attach and detach child objects dynamically during runtime. |
| **[AttachableNode](attachablenode.md)**| Use an AttachableNode component to provide an attachment point for an [AttachableBehaviour](attachablebehaviour.md) component. |
-| **[ComponentController](componentcontroller.md)**| Use a [ComponentController](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.ComponentController.html) component to enable or disable one or more components depending on the authority state of the ComponentController and have those changes synchronized with non-authority instances. |
+| **[ComponentController](componentcontroller.md)**| Use a [ComponentController](xref:Unity.Netcode.ComponentController) component to enable or disable one or more components depending on the authority state of the ComponentController and have those changes synchronized with non-authority instances. |
| **[NetworkAnimator](networkanimator.md)**| The NetworkAnimator component provides you with a fundamental example of how to synchronize animations during a network session. Animation states are synchronized with players joining an existing network session and any client already connected before the animation state changing. |
| **[NetworkRigidbody](networkrigidbody.md)**| NetworkRigidbody is a component that sets the Rigidbody of the GameObject into kinematic mode on all non-authoritative instances. |
-| **[NetworkTransform](networktransform.md)**| [NetworkTransform](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.Components.NetworkTransform.html) is a concrete class that inherits from [NetworkBehaviour](../core/networkbehaviour.md) and synchronizes [Transform](https://docs.unity3d.com/Manual/class-Transform.html) properties across the network, ensuring that the position, rotation, and scale of a [GameObject](https://docs.unity3d.com/Manual/working-with-gameobjects.html) are replicated to other clients. |
+| **[NetworkTransform](networktransform.md)**| [NetworkTransform](xref:Unity.Netcode.Components.NetworkTransform) is a concrete class that inherits from [NetworkBehaviour](../core/networkbehaviour.md) and synchronizes [Transform](https://docs.unity3d.com/Manual/class-Transform.html) properties across the network, ensuring that the position, rotation, and scale of a [GameObject](https://docs.unity3d.com/Manual/working-with-gameobjects.html) are replicated to other clients. |
| **[Physics](../../advanced-topics/physics.md)**| Netcode for GameObjects has a built in approach which allows for server-authoritative physics where the physics simulation only runs on the server. |
diff --git a/com.unity.netcode.gameobjects/Documentation~/components/helper/networkrigidbody.md b/com.unity.netcode.gameobjects/Documentation~/components/helper/networkrigidbody.md
index 8f412f7898..b931d59afb 100644
--- a/com.unity.netcode.gameobjects/Documentation~/components/helper/networkrigidbody.md
+++ b/com.unity.netcode.gameobjects/Documentation~/components/helper/networkrigidbody.md
@@ -12,7 +12,7 @@ When looking at a NetworkRigidbody in the Inspector view, there are three expose
- When enabled and using a [NetworkTransform](networktransform.md), the NetworkTransform uses the PhysX position and rotation to synchronize changes during the `FixedUpdate` loop update stage.
- __Auto Update Kinematic State__
- When enabled, NetworkRigidbody automatically determines whether the current instance should be kinematic or non-kinematic.
- - For custom solutions, you can opt to disable this field or derive from [NetworkRigidbodyBase](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@2.5/api/Unity.Netcode.Components.NetworkRigidbodyBase.html) and design your own custom networked Rigidbody handler.
+ - For custom solutions, you can opt to disable this field or derive from [NetworkRigidbodyBase](xref:Unity.Netcode.Components.NetworkRigidbodyBase) and design your own custom networked Rigidbody handler.
- __Auto Set Kinematic On Despawn__
- When enabled, this option makes the rigid body kinematic when despawned (which can be useful for [object pools](../../advanced-topics/object-pooling.md)).
@@ -25,7 +25,7 @@ Some collision events aren't fired when using NetworkRigidBody:
- You can adjust the __Contact Pairs Mode__ to use kinematic and non-kinematic by setting it to __Enable All Contact Pairs__.
> [!NOTE]
-> If there's a need for a gameplay event to happen on a collision, you can listen to the `OnCollisionEnter` function on the server and synchronize the event via `Rpc(SendTo.Everyone)` to all clients. If you plan on handling many collisions, then it's recommended to use the [RigidbodyContactEventManager component](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.Components.RigidbodyContactEventManager.html) to handle collision checking during a job (`OnCollisionenter` can become expensive from a processing perspective if you have enough instances colliding).
+> If there's a need for a gameplay event to happen on a collision, you can listen to the `OnCollisionEnter` function on the server and synchronize the event via `Rpc(SendTo.Everyone)` to all clients. If you plan on handling many collisions, then it's recommended to use the [RigidbodyContactEventManager component](xref:Unity.Netcode.Components.RigidbodyContactEventManager) to handle collision checking during a job (`OnCollisionenter` can become expensive from a processing perspective if you have enough instances colliding).
### NetworkRigidbody2D
diff --git a/com.unity.netcode.gameobjects/Documentation~/components/helper/networktransform.md b/com.unity.netcode.gameobjects/Documentation~/components/helper/networktransform.md
index b77c930647..8db6f66114 100644
--- a/com.unity.netcode.gameobjects/Documentation~/components/helper/networktransform.md
+++ b/com.unity.netcode.gameobjects/Documentation~/components/helper/networktransform.md
@@ -1,6 +1,6 @@
# NetworkTransform
-[NetworkTransform](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.Components.NetworkTransform.html) is a concrete class that inherits from [NetworkBehaviour](../core/networkbehaviour.md) and synchronizes [Transform](https://docs.unity3d.com/Manual/class-Transform.html) properties across the network, ensuring that the position, rotation, and scale of a [GameObject](https://docs.unity3d.com/Manual/working-with-gameobjects.html) are replicated to other clients.
+[NetworkTransform](xref:Unity.Netcode.Components.NetworkTransform) is a concrete class that inherits from [NetworkBehaviour](../core/networkbehaviour.md) and synchronizes [Transform](https://docs.unity3d.com/Manual/class-Transform.html) properties across the network, ensuring that the position, rotation, and scale of a [GameObject](https://docs.unity3d.com/Manual/working-with-gameobjects.html) are replicated to other clients.
The synchronization of a GameObject's Transform is a key netcode task, and usually proceeds in the following order:
@@ -39,7 +39,7 @@ Theoretically, you can have a NetworkTransform on every child object of a 100 le
When nesting NetworkTransforms, you should first determine if there are any alternative approaches to handling child object motion (such as synchronizing through animations or using an algorithm that uses the synchronized network time) to ensure you're not consuming unnecessary processing time and bandwidth.
-For example, if you use a [NetworkAnimator](networkanimator.md) component to synchronize animations (instead of nested NetworkTransforms), then you don't need to manage synchronizing each child node of the model because the animation system and NetworkAnimator handle it for you. Similarly, if you want a child object to orbit its parent object, you can use the server time ([`NetworkManager.ServerTime`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?sufolder=/api/Unity.Netcode.NetworkManager.html#Unity_Netcode_NetworkManager_ServerTime)) to feed into an algorithm that's used on all instances (local and remote). This removes the need to synchronize motion between child and parent because the algorithm is driven by a value that's already being synchronized on all clients.
+For example, if you use a [NetworkAnimator](networkanimator.md) component to synchronize animations (instead of nested NetworkTransforms), then you don't need to manage synchronizing each child node of the model because the animation system and NetworkAnimator handle it for you. Similarly, if you want a child object to orbit its parent object, you can use the server time ([`NetworkManager.ServerTime`](xref:Unity.Netcode.NetworkManager.ServerTime)) to feed into an algorithm that's used on all instances (local and remote). This removes the need to synchronize motion between child and parent because the algorithm is driven by a value that's already being synchronized on all clients.
> [!NOTE]
> Generally, unless you have some unique motion that needs to be applied to a child object and it can't be synchronized through an animation or an algorithm based on a synchronized value, then you shouldn't nest NetworkTransforms. However, nesting NetworkTransforms is more optimal then creating multiple individual single-node network prefabs with NetworkTransforms and parenting those once they're spawned.
@@ -58,13 +58,13 @@ Some NetworkTransform properties are automatically synchronized by the authorita
The following are a list of NetworkTransform properties that will cause a full state update (effectively a teleport) when changed during runtime by the authority instance:
-- [UseUnreliableDeltas](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@2.3/api/Unity.Netcode.Components.NetworkTransform.html#Unity_Netcode_Components_NetworkTransform_UseUnreliableDeltas)
-- [InLocalSpace](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@2.3/api/Unity.Netcode.Components.NetworkTransform.html#Unity_Netcode_Components_NetworkTransform_InLocalSpace)
-- [Interpolate](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@2.3/api/Unity.Netcode.Components.NetworkTransform.html#Unity_Netcode_Components_NetworkTransform_Interpolate)
-- [SlerpPosition](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@2.3/api/Unity.Netcode.Components.NetworkTransform.html#Unity_Netcode_Components_NetworkTransform_SlerpPosition)
-- [UseQuaternionSynchronization](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@2.3/api/Unity.Netcode.Components.NetworkTransform.html#Unity_Netcode_Components_NetworkTransform_UseQuaternionSynchronization)
-- [UseQuaternionCompression](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@2.3/api/Unity.Netcode.Components.NetworkTransform.html#Unity_Netcode_Components_NetworkTransform_UseQuaternionCompression)
-- [UseHalfFloatPrecision](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@2.3/api/Unity.Netcode.Components.NetworkTransform.html#Unity_Netcode_Components_NetworkTransform_UseHalfFloatPrecision)
+- [UseUnreliableDeltas](xref:Unity.Netcode.Components.NetworkTransform.UseUnreliableDeltas)
+- [InLocalSpace](xref:Unity.Netcode.Components.NetworkTransform.InLocalSpace)
+- [Interpolate](xref:Unity.Netcode.Components.NetworkTransform.Interpolate)
+- [SlerpPosition](xref:Unity.Netcode.Components.NetworkTransform.SlerpPosition)
+- [UseQuaternionSynchronization](xref:Unity.Netcode.Components.NetworkTransform.UseQuaternionSynchronization)
+- [UseQuaternionCompression](xref:Unity.Netcode.Components.NetworkTransform.UseQuaternionCompression)
+- [UseHalfFloatPrecision](xref:Unity.Netcode.Components.NetworkTransform.UseHalfFloatPrecision)
The following NetworkTransform properties can cause a full state update when changed during runtime by the authority instance:
diff --git a/com.unity.netcode.gameobjects/Documentation~/install.md b/com.unity.netcode.gameobjects/Documentation~/install.md
index 9fb1b54ef6..c3e5b597ec 100644
--- a/com.unity.netcode.gameobjects/Documentation~/install.md
+++ b/com.unity.netcode.gameobjects/Documentation~/install.md
@@ -7,7 +7,7 @@ Follow the instructions on this page to set up Netcode for GameObjects in your U
Before you begin, you need the following:
- An active Unity account with a valid license.
-- A supported version of Unity. Check [Netcode for GameObjects' requirements](#netcode-installation-requirements) for the specific version details.
+- A supported version of Unity. Check [Netcode for GameObjects' requirements](#compatibility) for the specific version details.
- An existing Unity project. If you're new to Unity, you can refer to the [get started](./tutorials/get-started-with-ngo.md) section for guidance.
### Compatibility
diff --git a/com.unity.netcode.gameobjects/Documentation~/learn/dealing-with-latency.md b/com.unity.netcode.gameobjects/Documentation~/learn/dealing-with-latency.md
index a14cc6d0da..e1c5b056ca 100644
--- a/com.unity.netcode.gameobjects/Documentation~/learn/dealing-with-latency.md
+++ b/com.unity.netcode.gameobjects/Documentation~/learn/dealing-with-latency.md
@@ -52,7 +52,7 @@ Note here an input from a client can be anything, from a user interacting with a
#### Issue: Reactivity
-An issue with server authority is you're waiting for your server to tell you to update your world. This means that if you send an input to the server and wait for the server to tell you your position change, you'll need to wait for a full **RTT** before you see the effect. There are [patterns](#patterns-to-solve-these-issues) you can use to solve this issue while still remaining server authoritative.
+An issue with server authority is you're waiting for your server to tell you to update your world. This means that if you send an input to the server and wait for the server to tell you your position change, you'll need to wait for a full **RTT** before you see the effect. There are [patterns](#patterns-to-solve-latency-issues-in-a-server-authoritative-game) you can use to solve this issue while still remaining server authoritative.
### Client authority
@@ -82,7 +82,7 @@ To avoid this, it's recommended to use client **owner** authority, which allows
Client authority is a pretty dangerous door to leave open on your server because any malicious player can forge messages to say "kill player a, b, c, d, e, f, g" and win the game. It's pretty useful though for reactivity. Since the client is making all the important gameplay decisions, it can display the result of user inputs as soon as they happen instead of waiting a few hundred milliseconds.
-When you don't think there's any reason for your players to cheat, client authority can be a great way to have reactivity without the complexity added with techniques like [input prediction](#prediction).
+When you don't think there's any reason for your players to cheat, client authority can be a great way to have reactivity without the complexity added with techniques like [input prediction](#client-side-prediction).
Another way of solving this issue in a client authoritative game is using soft validation server side. Instead of doing all simulation server side, the server only does basic validation. The server would, for example, do range checks to make sure a player isn't teleporting to places it shouldn't. Doing so is acceptable for most [PvE](https://en.wikipedia.org/wiki/Player_versus_environment) games. However, [PvP](https://en.wikipedia.org/wiki/Player_versus_player) games usually require server authority.
@@ -157,7 +157,7 @@ To do continuous client driven actions, there's a few more considerations to tak
- You then need to make sure you don't send RPCs to the server (containing your authoritative state) when no data has changed and do dirty checks.
- You'd need to send it on tick or at worst on FixedUpdate. Sending on Update() would spam your connection.
-A sample for a [ClientNetworkTransform](../components/helper/networktransform.md#clientnetworktransform) has been created, so you don't have to reimplement this yourself for transform updates. A [sample](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.bitesize/tree/main/Basic/ClientDriven) has been created on how to use it. See [movement script](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.bitesize/blob/v1.2.1/Basic/ClientDriven/Assets/Scripts/ClientPlayerMove.cs).
+A sample for a [ClientNetworkTransform](../components/helper/networktransform.md#client-vs-server-authority) has been created, so you don't have to reimplement this yourself for transform updates. A [sample](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.bitesize/tree/main/Basic/ClientDriven) has been created on how to use it. See [movement script](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.bitesize/blob/v1.2.1/Basic/ClientDriven/Assets/Scripts/ClientPlayerMove.cs).
> [!NOTE]
> A rule of thumb here is to ask yourself: "Can the server correct me on this?". If it can, use server authority.
diff --git a/com.unity.netcode.gameobjects/Documentation~/learn/listenserverhostarchitecture.md b/com.unity.netcode.gameobjects/Documentation~/learn/listenserverhostarchitecture.md
index e32e3858c8..d85764142b 100644
--- a/com.unity.netcode.gameobjects/Documentation~/learn/listenserverhostarchitecture.md
+++ b/com.unity.netcode.gameobjects/Documentation~/learn/listenserverhostarchitecture.md
@@ -33,7 +33,7 @@ In contrast to dedicated servers, listen servers are cheaper without the need to
## Connecting to a listen server
-Personal computers are hidden behind NATs (Network Address Translation devices) and routers to protect them from direct access. To connect to a listen server, you may choose an option such as [port forwarding](#port-forwarding), a [relay server](#relay-server), [NAT punch-through](#nat-punchthrough), or a [NAT punch with relay fallback](#nat-punch-and-relay-fallback).
+Personal computers are hidden behind NATs (Network Address Translation devices) and routers to protect them from direct access. To connect to a listen server, you may choose an option such as [port forwarding](#port-forwarding), a [relay server](#relay-server), [NAT punch-through](#nat-punch-through), or a [NAT punch with relay fallback](#nat-punch-and-relay-fallback).
### Port Forwarding
diff --git a/com.unity.netcode.gameobjects/Documentation~/learn/rpcvnetvar.md b/com.unity.netcode.gameobjects/Documentation~/learn/rpcvnetvar.md
index 0713cbab28..3d31914ddb 100644
--- a/com.unity.netcode.gameobjects/Documentation~/learn/rpcvnetvar.md
+++ b/com.unity.netcode.gameobjects/Documentation~/learn/rpcvnetvar.md
@@ -1,7 +1,7 @@
# RPC vs NetworkVariable
Choosing the wrong data syncing mechanism can create bugs, use too much bandwidth, and add too much complexity to your code.
-Netcode for GameObjects (Netcode) has two main ways of syncing information between players: RPCs ([Remote Procedure Calls](../advanced-topics/messaging-system.md)) and replicated states [(`NetworkVariable`s)](../basics/networkvariable). They both send messages over the network. The logic and your design around how they send messages is what will make you choose one over the other.
+Netcode for GameObjects (Netcode) has two main ways of syncing information between players: RPCs ([Remote Procedure Calls](../advanced-topics/messaging-system.md)) and replicated states [(`NetworkVariable`s)](../basics/networkvariable.md). They both send messages over the network. The logic and your design around how they send messages is what will make you choose one over the other.
## Choosing between `NetworkVariable`s or RPCs
diff --git a/com.unity.netcode.gameobjects/Documentation~/learn/ticks-and-update-rates.md b/com.unity.netcode.gameobjects/Documentation~/learn/ticks-and-update-rates.md
index 2ab45e73c2..dac2bc523a 100644
--- a/com.unity.netcode.gameobjects/Documentation~/learn/ticks-and-update-rates.md
+++ b/com.unity.netcode.gameobjects/Documentation~/learn/ticks-and-update-rates.md
@@ -16,7 +16,7 @@ When a server fails to process all incoming client data before the end of the cu
Update rate is a measure of how frequently the client sends and receives data to and from the server. It's also measured in hertz and, like tick rate, a higher update rate results in a more responsive game at the cost of increased processing and network demands on the client and server.
-
+
In addition to adding to perceived latency, low update rates can cause their own issues, such as multiple updates being bundled together and arriving at the same time, causing undesirable behavior.
@@ -24,7 +24,7 @@ In the example of 'super bullets': if an in-game gun is capable of shooting more
The diagram below illustrates the difference between a 10 Hz update rate and a 60 Hz update rate. With a 10 Hz update rate, the game sends updates to the server ten times a second, so a gun that can fire 600 rounds per minute (RPM), or ten times a second, will only ever send a single bullet per update. A gun that fires at 750 RPM, more than ten times a second, will end up running into the super bullet problem. A higher update rate of 60 Hz resolves this issue, ensuring that there are enough updates for each bullet to arrive separately in its own update.
-
+
### Discrepancy between tick rate and update rate
diff --git a/com.unity.netcode.gameobjects/Documentation~/migratingfromUNet.md b/com.unity.netcode.gameobjects/Documentation~/migratingfromUNet.md
index ee35801235..8d58a3366d 100644
--- a/com.unity.netcode.gameobjects/Documentation~/migratingfromUNet.md
+++ b/com.unity.netcode.gameobjects/Documentation~/migratingfromUNet.md
@@ -115,7 +115,7 @@ public class MyNetcodeExample : NetworkBehaviour
}
```
-Refer to [NetworkBehaviour](basics/networkbehaviour.md) for more information.
+Refer to [NetworkBehaviour](components/core/networkbehaviour.md) for more information.
## Replace SyncVar
@@ -343,7 +343,7 @@ Refer to [Object Spawning](basics/object-spawning.md) for more information.
## Custom Spawn Handlers
-Netcode has `Custom Spawn Handlers` to replace UNet's `Custom Spawn Functions`. See [Object Pooling](../advanced-topics/object-pooling) for more information.
+Netcode has `Custom Spawn Handlers` to replace UNet's `Custom Spawn Functions`. See [Object Pooling](advanced-topics/object-pooling.md) for more information.
## Replace `NetworkContextProperties`
diff --git a/com.unity.netcode.gameobjects/Documentation~/networkbehaviour-landing.md b/com.unity.netcode.gameobjects/Documentation~/networkbehaviour-landing.md
index c690759906..8d1cbeac17 100644
--- a/com.unity.netcode.gameobjects/Documentation~/networkbehaviour-landing.md
+++ b/com.unity.netcode.gameobjects/Documentation~/networkbehaviour-landing.md
@@ -5,5 +5,5 @@ Understand how to use NetworkBehaviour components in your project.
| **Topic** | **Description** |
| :------------------------------ | :------------------------------- |
-| **[NetworkBehaviour](components/core/networkbehaviour.md)** | [NetworkBehaviour](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkBehaviour.html) is an abstract class that derives from [MonoBehaviour](https://docs.unity3d.com/ScriptReference/MonoBehaviour.html) and is primarily used to create unique netcode or game logic. To replicate any netcode-aware properties or send and receive RPCs, a [GameObject](https://docs.unity3d.com/Manual/GameObjects.html) must have a [NetworkObject](components/core/networkobject.md) component and at least one NetworkBehaviour component. |
+| **[NetworkBehaviour](components/core/networkbehaviour.md)** | [NetworkBehaviour](xref:Unity.Netcode.NetworkBehaviour) is an abstract class that derives from [MonoBehaviour](https://docs.unity3d.com/ScriptReference/MonoBehaviour.html) and is primarily used to create unique netcode or game logic. To replicate any netcode-aware properties or send and receive RPCs, a [GameObject](https://docs.unity3d.com/Manual/GameObjects.html) must have a [NetworkObject](components/core/networkobject.md) component and at least one NetworkBehaviour component. |
| **[Synchronize](components/core/networkbehaviour-synchronize.md)** | You can use NetworkBehaviours to synchronize settings before, during, and after spawning NetworkObjects. |
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Documentation~/removed-tableofcontents.md b/com.unity.netcode.gameobjects/Documentation~/removed-tableofcontents.md
index e9eadb4428..224e9f2f47 100644
--- a/com.unity.netcode.gameobjects/Documentation~/removed-tableofcontents.md
+++ b/com.unity.netcode.gameobjects/Documentation~/removed-tableofcontents.md
@@ -10,7 +10,7 @@
* [Bitesize introduction](samples/bitesize/bitesize-introduction.md)
* [Bitesize space shooter](samples/bitesize/bitesize-spaceshooter.md)
* [Bitesize client driven](samples/bitesize/bitesize-clientdriven.md)
- * [Bitesize dynamic prefabs](samples/bitesize/bitesize-dynamicPrefabs.md)
+ * [Bitesize dynamic prefabs](samples/bitesize/bitesize-dynamicprefabs.md)
* [Bitesize social hub](samples/bitesize/bitesize-socialhub.md)
-->
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Documentation~/samples/bitesize/bitesize-landing.md b/com.unity.netcode.gameobjects/Documentation~/samples/bitesize/bitesize-landing.md
index 880fbb821e..1009a7343e 100644
--- a/com.unity.netcode.gameobjects/Documentation~/samples/bitesize/bitesize-landing.md
+++ b/com.unity.netcode.gameobjects/Documentation~/samples/bitesize/bitesize-landing.md
@@ -8,5 +8,5 @@ The Bite Size samples are small, focused examples that demonstrate specific feat
| **[Bitesize introduction](bitesize-introduction.md)** | The Bitesize Samples repository provides a series of sample code as modules to use in your games and better understand Netcode for GameObjects. |
| **[Bitesize space shooter](bitesize-spaceshooter.md)** | Learn more about physics movement and status effects using Netcode for GameObjects (Netcode) NetworkVariables and ObjectPooling. |
| **[Bitesize client driven](bitesize-clientdriven.md)** | Learn more about Client driven movements, networked physics, spawning vs statically placed objects, object reparenting. |
-| **[Bitesize dynamic prefabs](bitesize-dynamicPrefabs.md)** | Learn more about the dynamic Prefab system, which allows you to add new spawnable Prefabs at runtime. |
+| **[Bitesize dynamic prefabs](bitesize-dynamicprefabs.md)** | Learn more about the dynamic Prefab system, which allows you to add new spawnable Prefabs at runtime. |
| **[Bitesize social hub](bitesize-socialhub.md)** | The Distributed Authority Social Hub Sample is a project that demonstrates Distributed Authority's features and helps you integrate Distributed Authority into your own game projects. |
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Documentation~/samples/bitesize/bitesize-usecases.md b/com.unity.netcode.gameobjects/Documentation~/samples/bitesize/bitesize-usecases.md
index ebdbfc5705..a41c3d1238 100644
--- a/com.unity.netcode.gameobjects/Documentation~/samples/bitesize/bitesize-usecases.md
+++ b/com.unity.netcode.gameobjects/Documentation~/samples/bitesize/bitesize-usecases.md
@@ -16,11 +16,11 @@ The tutorials that open with each scene use the [Tutorial Framework package](htt
## The Anticipation scene
The Anticipation scene demonstrates the Client Anticipation feature of Netcode for GameObjects in the following use cases:
-- [`AnticipatedNetworkVariable`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@2.2/api/Unity.Netcode.AnticipatedNetworkVariable-1.html):
+- [`AnticipatedNetworkVariable`](xref:Unity.Netcode.AnticipatedNetworkVariable%601):
- Anticipate server actions based on player interaction to change NetworkVariables responsively.
- Compensate for latency that the server causes when it changes a value.
- Handle incorrect anticipation.
-- [`AnticipatedNetworkTransform`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@2.2/api/Unity.Netcode.Components.AnticipatedNetworkTransform.html):
+- [`AnticipatedNetworkTransform`](xref:Unity.Netcode.Components.AnticipatedNetworkTransform):
- Responsive server-authoritative player movement.
- Smooth player movement across clients.
diff --git a/com.unity.netcode.gameobjects/Documentation~/samples/bossroom/getting-started-boss-room.md b/com.unity.netcode.gameobjects/Documentation~/samples/bossroom/getting-started-boss-room.md
index 096d7f72db..214a8fdae5 100644
--- a/com.unity.netcode.gameobjects/Documentation~/samples/bossroom/getting-started-boss-room.md
+++ b/com.unity.netcode.gameobjects/Documentation~/samples/bossroom/getting-started-boss-room.md
@@ -25,8 +25,8 @@ Join the multiplayer community on the Unity [Discord](https://discord.gg/mNgM2XR
### Contents and quick links
- [Boss Room Overview](#boss-room-overview)
-- [Install the Boss Room project](#getting-the-project)
- - [Install Git LFS to clone locally](#installing-git-lfs-to-clone-locally)
+- [Install the Boss Room project](#install-the-boss-room-project)
+ - [Install Git LFS to clone locally](#install-git-lfs-to-clone-locally)
- [Direct download](#direct-download)
- [Registering the project with Unity Gaming Services (UGS)](#registering-the-project-with-unity-gaming-services-ugs)
- [Opening the project for the first time](#opening-the-project-for-the-first-time)
diff --git a/com.unity.netcode.gameobjects/Documentation~/samples/bossroom/optimizing-bossroom.md b/com.unity.netcode.gameobjects/Documentation~/samples/bossroom/optimizing-bossroom.md
index 234830e4c0..ddde94a432 100644
--- a/com.unity.netcode.gameobjects/Documentation~/samples/bossroom/optimizing-bossroom.md
+++ b/com.unity.netcode.gameobjects/Documentation~/samples/bossroom/optimizing-bossroom.md
@@ -73,19 +73,19 @@ The Boss Room sample shows how to adapt some Unity Transport properties to fit i
### Disconnect Timeout {#disconnect-timeout}
-The [Disconnect Timeout property](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.Transports.UTP.UnityTransport.html#Unity_Netcode_Transports_UTP_UnityTransport_DisconnectTimeoutMS) controls how long the server (and the clients) wait before disconnecting. The Boss Room sample uses a Disconnect Timeout value of 10 seconds to prevent the server and the clients from hanging onto a connection for too long.
+The [Disconnect Timeout property](xref:Unity.Netcode.Transports.UTP.UnityTransport.DisconnectTimeoutMS) controls how long the server (and the clients) wait before disconnecting. The Boss Room sample uses a Disconnect Timeout value of 10 seconds to prevent the server and the clients from hanging onto a connection for too long.
### Max Connect Attempts {#max-connect-attempts}
-The [Max Connect Attempts property](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.Transports.UTP.UnityTransport.html#Unity_Netcode_Transports_UTP_UnityTransport_MaxConnectAttempts) controls the times a client tries to connect before declaring a connection failure. The Boss Room sample uses a Max Connect Attempts value of 10 to prevent clients from waiting too long before declaring a connection failure.
+The [Max Connect Attempts property](xref:Unity.Netcode.Transports.UTP.UnityTransport.MaxConnectAttempts) controls the times a client tries to connect before declaring a connection failure. The Boss Room sample uses a Max Connect Attempts value of 10 to prevent clients from waiting too long before declaring a connection failure.
### Connect Timeout {#connect-timeout}
-The [Connect Timeout property](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.Transports.UTP.UnityTransport.html#Unity_Netcode_Transports_UTP_UnityTransport_ConnectTimeoutMS) controls the number of times clients attempt to connect per second. The Boss Room sample uses a Connect Timeout value of 1 second, meaning that clients try to connect once per second. Having the Connect Timeout set to 1 second and the Max Connect Attempts set to 10 means that clients fail to connect after 10 seconds of waiting.
+The [Connect Timeout property](xref:Unity.Netcode.Transports.UTP.UnityTransport.ConnectTimeoutMS) controls the number of times clients attempt to connect per second. The Boss Room sample uses a Connect Timeout value of 1 second, meaning that clients try to connect once per second. Having the Connect Timeout set to 1 second and the Max Connect Attempts set to 10 means that clients fail to connect after 10 seconds of waiting.
### Max Packet Queue Size {#max-packet-queue-size}
-The [Max Packet Queue Size property](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.Transports.UTP.UnityTransport.html#Unity_Netcode_Transports_UTP_UnityTransport_MaxPacketQueueSize) defines the maximum number of packets that can be sent and received during a single frame.
+The [Max Packet Queue Size property](xref:Unity.Netcode.Transports.UTP.UnityTransport.MaxPacketQueueSize) defines the maximum number of packets that can be sent and received during a single frame.
The impact of surpassing the Max Packet Queue Size threshold varies depending on the packet direction (sending or receiving).
diff --git a/com.unity.netcode.gameobjects/Documentation~/serialization.md b/com.unity.netcode.gameobjects/Documentation~/serialization.md
index fb39fad334..51aee596eb 100644
--- a/com.unity.netcode.gameobjects/Documentation~/serialization.md
+++ b/com.unity.netcode.gameobjects/Documentation~/serialization.md
@@ -4,11 +4,14 @@ Netcode for GameObjects has built-in serialization support for C# and Unity prim
| **Topic** | **Description** |
| :------------------------------ | :------------------------------- |
+| **[Serialization overview](advanced-topics/serialization/serialization-overview.md)** | An overview of how Netcode for GameObjects handles serialization. |
| **[C# primitives](advanced-topics/serialization/cprimitives.md)** | C# primitive types are serialized by built-in serialization code. These types include `bool`, `char`, `sbyte`, `byte`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `float`, `double`, and `string`. |
| **[Unity primitives](advanced-topics/serialization/unity-primitives.md)** | Unity Primitive `Color`, `Color32`, `Vector2`, `Vector3`, `Vector4`, `Quaternion`, `Ray`, `Ray2D` types will be serialized by built-in serialization code. |
| **[Enum types](advanced-topics/serialization/enum-types.md)** | A user-defined enum type will be serialized by built-in serialization code (with underlying integer type). |
| **[Arrays](advanced-topics/serialization/serialization-arrays.md)** | Netcode for GameObjects has built-in serialization code for arrays of [C# value-type primitives](advanced-topics/serialization/cprimitives.md), like `int[]`, and [Unity primitive types](advanced-topics/serialization/unity-primitives.md). Any arrays of types that aren't handled by the built-in serialization code, such as `string[]`, need to be handled using a container class or structure that implements the [`INetworkSerializable`](advanced-topics/serialization/inetworkserializable.md) interface. |
-| **[INetworkSerializable](advanced-topics/serialization/inetworkserializable.md)** | You can use the `INetworkSerializable` interface to define custom serializable types. |
+| **[Customize serializable types with INetworkSerializable](advanced-topics/serialization/inetworkserializable.md)** | You can use the `INetworkSerializable` interface to define custom serializable types. |
+| **[Serialize unmanaged structs with INetworkSerializeByMemcpy](advanced-topics/serialization/inetworkserializebymemcpy.md)** | You can use the `INetworkSerializeByMemcpy` interface to mark an unmanaged struct type as being trivially serializable. |
| **[Custom serialization](advanced-topics/custom-serialization.md)** | Create custom serialization types. |
| **[NetworkObject serialization](advanced-topics/serialization/networkobject-serialization.md)** | `GameObjects`, `NetworkObjects` and NetworkBehaviour aren't serializable types so they can't be used in `RPCs` or `NetworkVariables` by default. There are two convenience wrappers which can be used to send a reference to a NetworkObject or a NetworkBehaviour over RPCs or `NetworkVariables`. |
-| **[FastBufferWriter and FastBufferReader](advanced-topics/fastbufferwriter-fastbufferreader.md)** | The serialization and deserialization is done via `FastBufferWriter` and `FastBufferReader`. These have methods for serializing individual types and methods for serializing packed numbers, but in particular provide a high-performance method called `WriteValue()/ReadValue()` (for Writers and Readers, respectively) that can extremely quickly write an entire unmanaged struct to a buffer. |
\ No newline at end of file
+| **[FastBufferWriter and FastBufferReader](advanced-topics/fastbufferwriter-fastbufferreader.md)** | The serialization and deserialization is done via `FastBufferWriter` and `FastBufferReader`. These have methods for serializing individual types and methods for serializing packed numbers, but in particular provide a high-performance method called `WriteValue()/ReadValue()` (for Writers and Readers, respectively) that can extremely quickly write an entire unmanaged struct to a buffer. |
+| **[BufferSerializer](advanced-topics/bufferserializer.md)** | A bi-directional serializer primarily used for serializing within [`INetworkSerializable`](advanced-topics/serialization/inetworkserializable.md) types. |
diff --git a/com.unity.netcode.gameobjects/Documentation~/terms-concepts/distributed-authority.md b/com.unity.netcode.gameobjects/Documentation~/terms-concepts/distributed-authority.md
index 74f49a39c8..17c1f8b77b 100644
--- a/com.unity.netcode.gameobjects/Documentation~/terms-concepts/distributed-authority.md
+++ b/com.unity.netcode.gameobjects/Documentation~/terms-concepts/distributed-authority.md
@@ -53,7 +53,7 @@ You can use this property to conditionally execute logic that should only run on
### Session owner NetworkObjects
-For game systems that should always be [owned](./ownership.md) by the session owner, you can set the NetworkObject to have the `OwnershipStatus.SessionOwner` [ownership permission](../advanced-topics/networkobject-ownership.md). This ensures that the NetworkObject always belongs to the current session owner. If that session owner disconnects or leaves the game, the ownership of that NetworkObject will be automatically moved to the newly selected session owner.
+For game systems that should always be [owned](./ownership.md) by the session owner, you can set the NetworkObject to have the `OwnershipStatus.SessionOwner` [ownership permission](../components/core/networkobject-ownership.md). This ensures that the NetworkObject always belongs to the current session owner. If that session owner disconnects or leaves the game, the ownership of that NetworkObject will be automatically moved to the newly selected session owner.
## NetworkObject distribution
diff --git a/com.unity.netcode.gameobjects/Documentation~/terms-concepts/ownership.md b/com.unity.netcode.gameobjects/Documentation~/terms-concepts/ownership.md
index 3d47f69024..56ff42526e 100644
--- a/com.unity.netcode.gameobjects/Documentation~/terms-concepts/ownership.md
+++ b/com.unity.netcode.gameobjects/Documentation~/terms-concepts/ownership.md
@@ -35,7 +35,7 @@ In [distributed authority](./distributed-authority.md) the owner of a NetworkObj
-When building your game you can use [ownership permissions](../advanced-topics/networkobject-ownership.md#ownership-permission-settings) to control how and when ownership of NetworkObjects can be transferred between clients.
+When building your game you can use [ownership permissions](../components/core/networkobject-ownership.md#ownership-permission-settings) to control how and when ownership of NetworkObjects can be transferred between clients.
NetworkObjects with the `OwnershipStatus.Distributable` permission will have their ownership automatically distributed between all connected game clients whenever a new client joins or an existing client leaves. This is the key mechanism in how the game simulation is distributed between clients in a distributed authority session.
@@ -48,4 +48,4 @@ The `IsOwner` property, which is available on both NetworkObjects and NetworkBeh
* [Authority](authority.md)
* [Client-server](client-server.md)
* [Distributed authority](distributed-authority.md)
-* [NetworkObject ownership](../advanced-topics/networkobject-ownership.md)
+* [NetworkObject ownership](../components/core/networkobject-ownership.md)
diff --git a/com.unity.netcode.gameobjects/Documentation~/tutorials/get-started-with-ngo.md b/com.unity.netcode.gameobjects/Documentation~/tutorials/get-started-with-ngo.md
index 4a80b3fd1a..bbd635c497 100644
--- a/com.unity.netcode.gameobjects/Documentation~/tutorials/get-started-with-ngo.md
+++ b/com.unity.netcode.gameobjects/Documentation~/tutorials/get-started-with-ngo.md
@@ -33,7 +33,7 @@ This section guides you through adding the essential components of a networked g
- [A NetworkManager component](#create-the-networkmanager-component)
- [A player object](#create-an-object-to-spawn-for-each-connected-player)
-- [A scene](#add-your-scene-to-the-build)
+- [A scene](#scene-management-and-the-scenes-in-build-list)
### Create the NetworkManager component
@@ -68,7 +68,7 @@ First, create the NetworkManager component:
### Create an object to spawn for each connected player
> [!NOTE]
-> When you drop the prefab into the **PlayerPrefab** slot, you're telling the library that when a client connects to the game, it automatically spawns this prefab as the character for the connecting client. Netcode for GameObjects won't spawn a player object if you don't have any prefab set as the **PlayerPrefab**. Refer to [Player Objects](../components/core/networkobject.md#finding-playerobjects).
+> When you drop the prefab into the **PlayerPrefab** slot, you're telling the library that when a client connects to the game, it automatically spawns this prefab as the character for the connecting client. Netcode for GameObjects won't spawn a player object if you don't have any prefab set as the **PlayerPrefab**. Refer to [Player Objects](../components/core/playerobjects.md#finding-playerobjects).
This section guides you through creating an object that spawns for each connected player.
@@ -111,7 +111,7 @@ Netcode for GameObjects comes with an integrated scene management solution that
Now that you have a **NetworkManager**, assigned a **PlayerPrefab**, and added your current scene to the scenes in build test, you can quickly verify everything is functioning/configured correctly via entering play mode in the Unity Editor. By starting a host, you are starting NetworkManager as both a server and a client at the same time.
-You can test your Hello World project using the Unity Editor or a command-line helper. If you choose the latter, refer to [Create a command line helper](../tutorials/command-line-helper/). Otherwise, refer to the following instructions to test using the Unity Editor. Only the Plane appears on the server until the first client connects. Then, Netcode for GameObjects spawns a new Player prefab for each connected client; however, they overlap in the Game view.
+You can test your Hello World project using the Unity Editor or a command-line helper. If you choose the latter, refer to [Create a command line helper](command-line-helper.md). Otherwise, refer to the following instructions to test using the Unity Editor. Only the Plane appears on the server until the first client connects. Then, Netcode for GameObjects spawns a new Player prefab for each connected client; however, they overlap in the Game view.
1. Select **Play** from the top of the Unity Editor to start the scene.
@@ -119,7 +119,7 @@ You can test your Hello World project using the Unity Editor or a command-line h
2. Select **NetworkManager** from the **Hierarchy** list.
-
+
3. With **NetworkManager** selected (in the Hierarchy tab), select **Start Host** from the **Inspector** tab. Alternatively, you can use the in-game GUI buttons.
@@ -239,7 +239,7 @@ The `HelloWorldManager.cs` script accomplishes this menu within the `StartButton
As seen in the earlier code snippet, the `HelloWorldManager.cs` script also uses the NetworkManager's instance via its singleton to grab properties like the `IsClient`, `IsServer`, and `IsLocalClient`. The `IsClient` and `IsServer` properties dictate the established connection state.
-The `HelloWorldManager.cs` script also introduces a new method called `SubmitNewPosition()` that the `HelloWorldPlayer` script uses to [create a simple RPC call](#add-simple-rpc-use).
+The `HelloWorldManager.cs` script also introduces a new method called `SubmitNewPosition()` that the `HelloWorldPlayer` script uses to [create a simple RPC call](#adding-rpcs-remote-procedure-calls).
## Adding RPCs (Remote Procedure Calls)
diff --git a/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/techniques_and_tricks_for_debugging_multiplayer_games.md b/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/techniques_and_tricks_for_debugging_multiplayer_games.md
index aadbec86b8..6f5bbcd88d 100644
--- a/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/techniques_and_tricks_for_debugging_multiplayer_games.md
+++ b/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/techniques_and_tricks_for_debugging_multiplayer_games.md
@@ -10,7 +10,7 @@ Below is a list of practices and techniques that we use daily when working on th
### Use ParrelSync clone-based workflow during development.
-[ParrelSync workflow](testing_locally.md#parrelsync) is faster than creating builds and it allows you to debug the separate editor instances via separate IDE debuggers.
+[ParrelSync workflow](testing_with_artificial_conditions.md#clone-based-workflow-parrelsync) is faster than creating builds and it allows you to debug the separate editor instances via separate IDE debuggers.
Use ParrelSync to run separate editor instances for your Host/Server and Client.
@@ -22,7 +22,7 @@ Unity engine has two debug rendering APIs that are useful for the purposes of mu
Both of these functions allow us to draw arbitrary debug lines that would be visible in the Scene view and in the Game view, provided Gizmo rendering is enabled (to enable Gizmo rendering in Game view you need to click on the `Gizmos` menu at the top of the Game view).
-The key trick here is to use different colors for different kinds of information and to make the lines stay long enough for visual inspection by setting `duration` parameter. This technique shines when it's combined with [screen recordings](#7-recording-the-video-of-gameplay) of [multiple peers running side by side in separate editor instances via ParrelSync](#1-use-parrelsync-workflow-during-development).
+The key trick here is to use different colors for different kinds of information and to make the lines stay long enough for visual inspection by setting `duration` parameter. This technique shines when it's combined with [screen recordings](#capturing-screen-recordings-of-the-game-instances) of [multiple peers running side by side in separate editor instances via ParrelSync](#use-parrelsync-clone-based-workflow-during-development).
The code below would render a green debug line that's 2 units tall at the position of the transform, and this line would stay on screen for 4 seconds:
`Debug.DrawLine(this.transform.position, this.transform.position + Vector3.UP * 2f, Color.green, duration: 4f);`
diff --git a/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/testing_with_artificial_conditions.md b/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/testing_with_artificial_conditions.md
index f3c0646638..634f84288a 100644
--- a/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/testing_with_artificial_conditions.md
+++ b/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/testing_with_artificial_conditions.md
@@ -11,11 +11,11 @@ This is challenging when we are [iterating on our game locally](testing_locally.
Thankfully there are a number of tools that can simulate adverse network conditions.
-For testing locally within the Editor, you can use the [Network Simulator tool](https://docs-multiplayer.unity3d.com/tools/current/tools-network-simulator/) along with [clone-based workflow via ParrelSync](testing_locally.md#parrelsync).
+For testing locally within the Editor, you can use the [Network Simulator tool](https://docs-multiplayer.unity3d.com/tools/current/tools-network-simulator/) along with [clone-based workflow via ParrelSync](#clone-based-workflow-parrelsync).
For testing development builds with built-in artificial latency we suggest using [Network Simulator tools with some custom code to inject artificial conditions into the build](#debug-builds).
-For testing release builds we suggest using [Clumsy](#clumsy-windows) if you're on Windows and Network Link Conditioner if you're on [macOS](#network-link-conditioner-mac-os) or [iOS](#network-link-conditioner-ios). A scriptable alternative to Network Link Conditioner on macOS is [dummynet](#dummynet-dnctl-and-pftcl-mac-os), which offers great control and comes packaged with the operating system.
+For testing release builds we suggest using [Clumsy](#clumsy-windows) if you're on Windows and Network Link Conditioner if you're on [macOS](#network-link-conditioner-macos) or [iOS](#network-link-conditioner-ios). A scriptable alternative to Network Link Conditioner on macOS is [dummynet](#dummynet-dnctl-and-pftcl-macos), which offers great control and comes packaged with the operating system.
> [!NOTE]
> While artificial latency is great for simulating network conditions during development - it won't accurately emulate real world conditions. We recommend to test your game often on the targeted platforms and real live networking conditions.
@@ -49,7 +49,7 @@ Adding packet loss, apart from introducing even more effective delay to our syst
### Different network conditions for different peers
-[Clumsy](#clumsy-on-windows), [Network Link Conditioner](#network-link-conditioner-mac-os) and [dummynet](#dummynet-dnctl-and-pftcl-mac-os) are introducing changes on OS level, thus all the instances of the game that we open on our local machine would run under the same network conditions.
+[Clumsy](#clumsy-windows), [Network Link Conditioner](#network-link-conditioner-macos) and [dummynet](#dummynet-dnctl-and-pftcl-macos) are introducing changes on OS level, thus all the instances of the game that we open on our local machine would run under the same network conditions.
Don't forget to disable it once you're done debugging, else your network connection will feel slow!
@@ -65,7 +65,7 @@ In this case we would want to have an ability to set artificial conditions on a
> ParallelSync is **not** supported by Unity. More information on its usage is available [here](https://github.com/VeriorPies/ParrelSync). Troubleshooting information can be found [here](https://github.com/VeriorPies/ParrelSync/wiki/Troubleshooting-&-FAQs)
-Simulator Tools effects only apply to editor instances and to [debug builds](#debug-builds), as such it matches well with [clone-based workflow via ParrelSync](testing_locally.md#parrelsync).
+Simulator Tools effects only apply to editor instances and to [debug builds](#debug-builds), as such it matches well with [clone-based workflow via ParrelSync](#clone-based-workflow-parrelsync).
Other tools should be used when testing release builds locally.
diff --git a/com.unity.netcode.gameobjects/Editor/CodeGen/NetworkBehaviourILPP.cs b/com.unity.netcode.gameobjects/Editor/CodeGen/NetworkBehaviourILPP.cs
index 04a72d7c9e..3794b976b0 100644
--- a/com.unity.netcode.gameobjects/Editor/CodeGen/NetworkBehaviourILPP.cs
+++ b/com.unity.netcode.gameobjects/Editor/CodeGen/NetworkBehaviourILPP.cs
@@ -2150,9 +2150,10 @@ private bool GetReadMethodForParameter(TypeReference paramType, out MethodRefere
{
typeMethod = GetFastBufferReaderReadMethod(k_ReadValueInPlaceMethodName, paramType);
}
- else
-#endif
+ else if (paramType.Resolve().FullName == "Unity.Collections.NativeArray`1")
+#else
if (paramType.Resolve().FullName == "Unity.Collections.NativeArray`1")
+#endif
{
typeMethod = GetFastBufferReaderReadMethod(k_ReadValueTempMethodName, paramType);
}
diff --git a/com.unity.netcode.gameobjects/Editor/CodeGen/RuntimeAccessModifiersILPP.cs b/com.unity.netcode.gameobjects/Editor/CodeGen/RuntimeAccessModifiersILPP.cs
index 57295be52e..18c73ed737 100644
--- a/com.unity.netcode.gameobjects/Editor/CodeGen/RuntimeAccessModifiersILPP.cs
+++ b/com.unity.netcode.gameobjects/Editor/CodeGen/RuntimeAccessModifiersILPP.cs
@@ -97,17 +97,23 @@ private void ProcessNetworkManager(TypeDefinition typeDefinition, string[] assem
{
foreach (var fieldDefinition in typeDefinition.Fields)
{
+#pragma warning disable CS0618 // Type or member is obsolete
if (fieldDefinition.Name == nameof(NetworkManager.__rpc_func_table))
+#pragma warning restore CS0618 // Type or member is obsolete
{
fieldDefinition.IsPublic = true;
}
+#pragma warning disable CS0618 // Type or member is obsolete
if (fieldDefinition.Name == nameof(NetworkManager.RpcReceiveHandler))
+#pragma warning restore CS0618 // Type or member is obsolete
{
fieldDefinition.IsPublic = true;
}
+#pragma warning disable CS0618 // Type or member is obsolete
if (fieldDefinition.Name == nameof(NetworkManager.__rpc_name_table))
+#pragma warning restore CS0618 // Type or member is obsolete
{
fieldDefinition.IsPublic = true;
}
@@ -115,7 +121,9 @@ private void ProcessNetworkManager(TypeDefinition typeDefinition, string[] assem
foreach (var nestedTypeDefinition in typeDefinition.NestedTypes)
{
+#pragma warning disable CS0618 // Type or member is obsolete
if (nestedTypeDefinition.Name == nameof(NetworkManager.RpcReceiveHandler))
+#pragma warning restore CS0618 // Type or member is obsolete
{
nestedTypeDefinition.IsNestedPublic = true;
}
@@ -151,7 +159,7 @@ private void ProcessNetworkBehaviour(TypeDefinition typeDefinition)
{
fieldDefinition.IsFamilyOrAssembly = true;
}
-#if MULTIPLAYER_TOOLS && (DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
+#if MULTIPLAYER_TOOLS && (DEBUG || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
if (fieldDefinition.Name == nameof(NetworkBehaviour.__rpc_name_table))
{
fieldDefinition.IsFamilyOrAssembly = true;
diff --git a/com.unity.netcode.gameobjects/Editor/InScenePlacedProcessor.cs b/com.unity.netcode.gameobjects/Editor/InScenePlacedProcessor.cs
new file mode 100644
index 0000000000..8f66c3aa4f
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Editor/InScenePlacedProcessor.cs
@@ -0,0 +1,74 @@
+using Unity.Netcode.Logging;
+using UnityEditor;
+using UnityEditor.Build;
+using UnityEditor.Build.Reporting;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace Unity.Netcode.Editor
+{
+ ///
+ /// A that sets the property to true for all s in the scene.
+ /// Ensures that InScenePlaced is always true for all objects in the scene.
+ ///
+ ///
+ /// This will always run as the game enters the scene,
+ ///
+ internal class SetInScenePlaced : IProcessSceneWithReport
+ {
+ public int callbackOrder => 0;
+ public void OnProcessScene(Scene scene, BuildReport report)
+ {
+ var log = new ContextualLogger();
+ log.AddInfo(scene.name, scene.handle);
+ foreach (var networkObject in FindObjects.FromSceneByType(scene, true))
+ {
+ // Trap for users just creating things during runtime where this will be zero.
+ if (networkObject.GlobalObjectIdHash == 0)
+ {
+ log.Warning(new Context(LogLevel.Developer, $"{nameof(NetworkObject)}'s GlobalObjectIdHash value is zero! Runtime creating of {nameof(NetworkObject)}s is not supported. Skipping processing.").AddNetworkObject(networkObject));
+ continue;
+ }
+ if (networkObject.SceneOrigin.IsValid() && networkObject.SceneOrigin.handle != scene.handle)
+ {
+ log.Warning(new Context(LogLevel.Developer, $"{nameof(NetworkObject)}'s SceneOrigin doesn't match current scene being processed! Skipping processing.").AddInfo("SceneOrigin", networkObject.SceneOriginHandle).AddNetworkObject(networkObject));
+ continue;
+ }
+
+ if (networkObject.HasBeenSpawned)
+ {
+ log.Error(new Context(LogLevel.Normal, $"Processing {nameof(NetworkObject)} that has already been spawned! This should not be possible. Skipping processing.").AddNetworkObject(networkObject));
+ continue;
+ }
+
+ // If already marked, the do nothing.
+ if (networkObject.InScenePlaced)
+ {
+ continue;
+ }
+
+ networkObject.InScenePlaced = true;
+ // Will not be true when making a build and the values are serialized.
+ networkObject.InScenePlacedPostProcessorMarkedDuringRuntime = Application.isPlaying;
+ }
+ }
+ }
+
+ ///
+ /// An that sets the property to false for all s in prefabs.
+ /// Ensures that InScenePlaced is always false for all prefab objects.
+ /// This is important because when a prefab is instantiated in the scene, it should be treated as a dynamically spawned object.
+ ///
+ internal class InScenePlacedPrefabBuilder : AssetPostprocessor
+ {
+ public void OnPostprocessPrefab(GameObject root)
+ {
+ var networkObjects = root.GetComponentsInChildren(true);
+ foreach (var networkObject in networkObjects)
+ {
+ networkObject.InScenePlaced = false;
+ }
+ }
+ }
+}
diff --git a/com.unity.netcode.gameobjects/Editor/InScenePlacedProcessor.cs.meta b/com.unity.netcode.gameobjects/Editor/InScenePlacedProcessor.cs.meta
new file mode 100644
index 0000000000..784aa38575
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Editor/InScenePlacedProcessor.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: cda0fb70bdcd545a7983ca78f516bcff
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Editor/NetworkBehaviourEditor.cs b/com.unity.netcode.gameobjects/Editor/NetworkBehaviourEditor.cs
index 1312ff69e6..c2ce7da626 100644
--- a/com.unity.netcode.gameobjects/Editor/NetworkBehaviourEditor.cs
+++ b/com.unity.netcode.gameobjects/Editor/NetworkBehaviourEditor.cs
@@ -322,18 +322,13 @@ private void OnEnable()
}
///
- /// Recursively finds the root parent of a
+ /// Obsolete method to find root parent of a .
+ /// Use instead.
///
/// The current we are inspecting for a parent
/// the root parent for the first passed into the method
- public static Transform GetRootParentTransform(Transform transform)
- {
- if (transform.parent == null || transform.parent == transform)
- {
- return transform;
- }
- return GetRootParentTransform(transform.parent);
- }
+ [Obsolete("Use transform.root instead")]
+ public static Transform GetRootParentTransform(Transform transform) => transform.root;
///
/// Used to determine if a GameObject has one or more NetworkBehaviours but
@@ -358,7 +353,7 @@ public static void CheckForNetworkObject(GameObject gameObject, bool networkObje
}
// Now get the root parent transform to the current GameObject (or itself)
- var rootTransform = GetRootParentTransform(gameObject.transform);
+ var rootTransform = gameObject.transform.root;
if (!rootTransform.TryGetComponent(out var networkManager))
{
networkManager = rootTransform.GetComponentInChildren();
diff --git a/com.unity.netcode.gameobjects/Editor/NetworkManagerHelper.cs b/com.unity.netcode.gameobjects/Editor/NetworkManagerHelper.cs
index 5c7e554baf..66ddb2b6f0 100644
--- a/com.unity.netcode.gameobjects/Editor/NetworkManagerHelper.cs
+++ b/com.unity.netcode.gameobjects/Editor/NetworkManagerHelper.cs
@@ -195,9 +195,9 @@ public bool NotifyUserOfNestedNetworkManager(NetworkManager networkManager, bool
{
return isParented;
}
- else // If we are no longer a child, then we can remove ourself from this list
- if (transform.root == gameObject.transform)
+ else if (transform.root == gameObject.transform)
{
+ // If we are no longer a child, then we can remove ourself from this list
s_LastKnownNetworkManagerParents.Remove(networkManager);
}
}
diff --git a/com.unity.netcode.gameobjects/Editor/NetworkObjectEditor.cs b/com.unity.netcode.gameobjects/Editor/NetworkObjectEditor.cs
index 04e0d1f698..0335896784 100644
--- a/com.unity.netcode.gameobjects/Editor/NetworkObjectEditor.cs
+++ b/com.unity.netcode.gameobjects/Editor/NetworkObjectEditor.cs
@@ -67,14 +67,10 @@ public override void OnInspectorGUI()
EditorGUILayout.Toggle(nameof(NetworkObject.IsOwner), m_NetworkObject.IsOwner);
EditorGUILayout.Toggle(nameof(NetworkObject.IsOwnedByServer), m_NetworkObject.IsOwnedByServer);
EditorGUILayout.Toggle(nameof(NetworkObject.IsPlayerObject), m_NetworkObject.IsPlayerObject);
- if (m_NetworkObject.IsSceneObject.HasValue)
- {
- EditorGUILayout.Toggle(nameof(NetworkObject.IsSceneObject), m_NetworkObject.IsSceneObject.Value);
- }
- else
- {
- EditorGUILayout.TextField(nameof(NetworkObject.IsSceneObject), "null");
- }
+#pragma warning disable CS0618 // Type or member is obsolete
+ // TODO-3.x: Update name in 3.x branch
+ EditorGUILayout.Toggle(nameof(NetworkObject.IsSceneObject), m_NetworkObject.InScenePlaced);
+#pragma warning restore CS0618 // Type or member is obsolete
EditorGUILayout.Toggle(nameof(NetworkObject.DestroyWithScene), m_NetworkObject.DestroyWithScene);
EditorGUILayout.TextField(nameof(NetworkObject.NetworkManager), m_NetworkObject.NetworkManager == null ? "null" : m_NetworkObject.NetworkManager.gameObject.name);
GUI.enabled = guiEnabled;
diff --git a/com.unity.netcode.gameobjects/Runtime/Components/AnticipatedNetworkTransform.cs b/com.unity.netcode.gameobjects/Runtime/Components/AnticipatedNetworkTransform.cs
index ce277533c7..00bd431cbb 100644
--- a/com.unity.netcode.gameobjects/Runtime/Components/AnticipatedNetworkTransform.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Components/AnticipatedNetworkTransform.cs
@@ -161,8 +161,18 @@ public void AnticipateMove(Vector3 newPosition)
{
return;
}
- transform.position = newPosition;
+
+ if (InLocalSpace)
+ {
+ transform.localPosition = newPosition;
+ }
+ else
+ {
+ transform.position = newPosition;
+ }
+
m_AnticipatedTransform.Position = newPosition;
+
if (CanCommitToTransform)
{
m_AuthoritativeTransform.Position = newPosition;
@@ -187,7 +197,15 @@ public void AnticipateRotate(Quaternion newRotation)
{
return;
}
- transform.rotation = newRotation;
+
+ if (InLocalSpace)
+ {
+ transform.localRotation = newRotation;
+ }
+ else
+ {
+ transform.rotation = newRotation;
+ }
m_AnticipatedTransform.Rotation = newRotation;
if (CanCommitToTransform)
{
@@ -240,7 +258,14 @@ public void AnticipateState(TransformState newState)
return;
}
var transform_ = transform;
- transform_.SetPositionAndRotation(newState.Position, newState.Rotation);
+ if (InLocalSpace)
+ {
+ transform_.SetLocalPositionAndRotation(newState.Position, newState.Rotation);
+ }
+ else
+ {
+ transform_.SetPositionAndRotation(newState.Position, newState.Rotation);
+ }
transform_.localScale = newState.Scale;
m_AnticipatedTransform = newState;
if (CanCommitToTransform)
@@ -277,7 +302,17 @@ private void ProcessSmoothing()
m_PreviousAnticipatedTransform = m_AnticipatedTransform;
if (!CanCommitToTransform)
{
- transform_.SetPositionAndRotation(m_AnticipatedTransform.Position, m_AnticipatedTransform.Rotation);
+ if (InLocalSpace)
+ {
+ transform_.SetLocalPositionAndRotation(m_AnticipatedTransform.Position,
+ m_AnticipatedTransform.Rotation);
+ }
+ else
+ {
+ transform_.SetPositionAndRotation(m_AnticipatedTransform.Position,
+ m_AnticipatedTransform.Rotation);
+ }
+
transform_.localScale = m_AnticipatedTransform.Scale;
}
}
@@ -320,12 +355,25 @@ public void SetupForRender()
if (Transform.CanCommitToTransform)
{
var transform_ = Transform.transform;
- Transform.m_AuthoritativeTransform = new TransformState
+ if (Transform.InLocalSpace)
{
- Position = transform_.position,
- Rotation = transform_.rotation,
- Scale = transform_.localScale
- };
+ Transform.m_AuthoritativeTransform = new TransformState
+ {
+ Position = transform_.localPosition,
+ Rotation = transform_.localRotation,
+ Scale = transform_.localScale
+ };
+ }
+ else
+ {
+ Transform.m_AuthoritativeTransform = new TransformState
+ {
+ Position = transform_.position,
+ Rotation = transform_.rotation,
+ Scale = transform_.localScale
+ };
+ }
+
if (Transform.m_CurrentSmoothTime >= Transform.m_SmoothDuration)
{
// If we've had a call to Smooth() we'll continue interpolating.
@@ -334,7 +382,17 @@ public void SetupForRender()
Transform.m_AnticipatedTransform = Transform.m_AuthoritativeTransform;
}
- transform_.SetPositionAndRotation(Transform.m_AnticipatedTransform.Position, Transform.m_AnticipatedTransform.Rotation);
+ if (Transform.InLocalSpace)
+ {
+ transform_.SetLocalPositionAndRotation(Transform.m_AnticipatedTransform.Position,
+ Transform.m_AnticipatedTransform.Rotation);
+ }
+ else
+ {
+ transform_.SetPositionAndRotation(Transform.m_AnticipatedTransform.Position,
+ Transform.m_AnticipatedTransform.Rotation);
+ }
+
transform_.localScale = Transform.m_AnticipatedTransform.Scale;
}
}
@@ -344,7 +402,17 @@ public void SetupForUpdate()
if (Transform.CanCommitToTransform)
{
var transform_ = Transform.transform;
- transform_.SetPositionAndRotation(Transform.m_AuthoritativeTransform.Position, Transform.m_AuthoritativeTransform.Rotation);
+ if (Transform.InLocalSpace)
+ {
+ transform_.SetLocalPositionAndRotation(Transform.m_AuthoritativeTransform.Position,
+ Transform.m_AuthoritativeTransform.Rotation);
+ }
+ else
+ {
+ transform_.SetPositionAndRotation(Transform.m_AuthoritativeTransform.Position,
+ Transform.m_AuthoritativeTransform.Rotation);
+ }
+
transform_.localScale = Transform.m_AuthoritativeTransform.Scale;
}
}
@@ -367,12 +435,25 @@ public void ResetAnticipation()
private void ResetAnticipatedState()
{
var transform_ = transform;
- m_AuthoritativeTransform = new TransformState
+ if (InLocalSpace)
+ {
+ m_AuthoritativeTransform = new TransformState
+ {
+ Position = transform_.localPosition,
+ Rotation = transform_.localRotation,
+ Scale = transform_.localScale
+ };
+ }
+ else
{
- Position = transform_.position,
- Rotation = transform_.rotation,
- Scale = transform_.localScale
- };
+ m_AuthoritativeTransform = new TransformState
+ {
+ Position = transform_.position,
+ Rotation = transform_.rotation,
+ Scale = transform_.localScale
+ };
+ }
+
m_AnticipatedTransform = m_AuthoritativeTransform;
m_PreviousAnticipatedTransform = m_AnticipatedTransform;
@@ -439,7 +520,7 @@ public override void OnNetworkSpawn()
return;
}
m_OutstandingAuthorityChange = true;
- ApplyAuthoritativeState();
+ //ApplyAuthoritativeState();
ResetAnticipatedState();
m_AnticipatedObject = new AnticipatedObject { Transform = this };
@@ -491,7 +572,15 @@ public void Smooth(TransformState from, TransformState to, float durationSeconds
{
m_AnticipatedTransform = to;
m_PreviousAnticipatedTransform = m_AnticipatedTransform;
- transform_.SetPositionAndRotation(to.Position, to.Rotation);
+ if (InLocalSpace)
+ {
+ transform_.SetLocalPositionAndRotation(to.Position, to.Rotation);
+ }
+ else
+ {
+ transform_.SetPositionAndRotation(to.Position, to.Rotation);
+ }
+
transform_.localScale = to.Scale;
m_SmoothDuration = 0;
m_CurrentSmoothTime = 0;
@@ -502,7 +591,15 @@ public void Smooth(TransformState from, TransformState to, float durationSeconds
if (!CanCommitToTransform)
{
- transform_.SetPositionAndRotation(from.Position, from.Rotation);
+ if (InLocalSpace)
+ {
+ transform_.SetLocalPositionAndRotation(from.Position, from.Rotation);
+ }
+ else
+ {
+ transform_.SetPositionAndRotation(from.Position, from.Rotation);
+ }
+
transform_.localScale = from.Scale;
}
@@ -543,14 +640,30 @@ protected override void OnTransformUpdated()
var previousAnticipatedTransform = m_AnticipatedTransform;
// Update authority state to catch any possible interpolation data
- m_AuthoritativeTransform.Position = transform_.position;
- m_AuthoritativeTransform.Rotation = transform_.rotation;
- m_AuthoritativeTransform.Scale = transform_.localScale;
+ if (InLocalSpace)
+ {
+ m_AuthoritativeTransform.Position = transform_.localPosition;
+ m_AuthoritativeTransform.Rotation = transform_.localRotation;
+ m_AuthoritativeTransform.Scale = transform_.localScale;
+ }
+ else
+ {
+ m_AuthoritativeTransform.Position = transform_.position;
+ m_AuthoritativeTransform.Rotation = transform_.rotation;
+ m_AuthoritativeTransform.Scale = transform_.localScale;
+ }
if (!m_OutstandingAuthorityChange)
{
// Keep the anticipated value unchanged, we have no updates from the server at all.
- transform_.SetPositionAndRotation(previousAnticipatedTransform.Position, previousAnticipatedTransform.Rotation);
+ if (InLocalSpace)
+ {
+ transform_.SetLocalPositionAndRotation(previousAnticipatedTransform.Position, previousAnticipatedTransform.Rotation);
+ }
+ else
+ {
+ transform_.SetPositionAndRotation(previousAnticipatedTransform.Position, previousAnticipatedTransform.Rotation);
+ }
transform_.localScale = previousAnticipatedTransform.Scale;
return;
}
@@ -558,7 +671,17 @@ protected override void OnTransformUpdated()
if (StaleDataHandling == StaleDataHandling.Ignore && m_LastAnticipaionCounter > m_LastAuthorityUpdateCounter)
{
// Keep the anticipated value unchanged because it is more recent than the authoritative one.
- transform_.SetPositionAndRotation(previousAnticipatedTransform.Position, previousAnticipatedTransform.Rotation);
+ if (InLocalSpace)
+ {
+ transform_.SetLocalPositionAndRotation(previousAnticipatedTransform.Position,
+ previousAnticipatedTransform.Rotation);
+ }
+ else
+ {
+ transform_.SetPositionAndRotation(previousAnticipatedTransform.Position,
+ previousAnticipatedTransform.Rotation);
+ }
+
transform_.localScale = previousAnticipatedTransform.Scale;
return;
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Components/Interpolator/BufferedLinearInterpolator.cs b/com.unity.netcode.gameobjects/Runtime/Components/Interpolator/BufferedLinearInterpolator.cs
index 24eb580402..4cee25748e 100644
--- a/com.unity.netcode.gameobjects/Runtime/Components/Interpolator/BufferedLinearInterpolator.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Components/Interpolator/BufferedLinearInterpolator.cs
@@ -209,12 +209,23 @@ public void Reset(T currentValue)
internal bool LerpSmoothEnabled;
///
- /// Determines how much smoothing will be applied to the 2nd lerp when using the (i.e. lerping and not smooth dampening).
+ /// The frame rate that is relative to when lerp smoothing.
+ ///
+ private const float k_LerpSmoothReferenceFrameRate = 60.0f;
+
+ ///
+ /// Keeps a of 1.0f from retaining the entire delta each frame,
+ /// which would stop the value from ever advancing towards the target.
+ ///
+ private const float k_MaximumLerpSmoothRetention = 0.99f;
+
+ ///
+ /// Determines how much smoothing will be applied to the 2nd lerp.
///
///
- /// There's two factors affecting interpolation:
- /// - Buffering: Which can be adjusted in set in the .
- /// - Interpolation time: The divisor applied to delta time where the quotient is used as the lerp time.
+ /// Higher values are smoother, lower values are more precise. The amount of smoothing applied is
+ /// frame rate independent.
+ /// Buffering also affects interpolation and can be adjusted via .
///
[Range(0.016f, 1.0f)]
public float MaximumInterpolationTime = 0.1f;
@@ -420,6 +431,26 @@ internal void ResetCurrentState()
}
}
+ ///
+ /// Calculates the frame rate independent lerp smoothing "t" for the current frame.
+ ///
+ ///
+ /// Raising the retained portion to the number of reference frames elapsed makes the smoothing rate
+ /// a function of elapsed time rather than of how often this is called.
+ ///
+ /// The last frame time.
+ /// The lerp smoothing time to apply for this frame.
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ private float GetLerpSmoothTime(float deltaTime)
+ {
+ var retained = Mathf.Clamp01(MaximumInterpolationTime);
+ if (retained >= 1.0f)
+ {
+ retained = k_MaximumLerpSmoothRetention;
+ }
+ return 1.0f - Mathf.Pow(retained, deltaTime * k_LerpSmoothReferenceFrameRate);
+ }
+
///
/// Interpolation Update to use when smooth dampening is enabled on a .
///
@@ -459,7 +490,7 @@ internal T Update(float deltaTime, double tickLatencyAsTime, double minDeltaTime
if (LerpSmoothEnabled)
{
// Apply the smooth lerp to the target to help smooth the final value.
- InterpolateState.CurrentValue = Interpolate(InterpolateState.CurrentValue, InterpolateState.NextValue, Mathf.Clamp(1.0f - MaximumInterpolationTime, 0.0f, 1.0f));
+ InterpolateState.CurrentValue = Interpolate(InterpolateState.CurrentValue, InterpolateState.NextValue, GetLerpSmoothTime(deltaTime));
}
else
{
@@ -467,8 +498,8 @@ internal T Update(float deltaTime, double tickLatencyAsTime, double minDeltaTime
InterpolateState.CurrentValue = InterpolateState.NextValue;
}
}
- else // If the target is reached and we have no more state updates, we want to check to see if we need to reset.
- if (m_BufferQueue.Count == 0)
+ // If the target is reached and we have no more state updates, we want to check to see if we need to reset.
+ else if (m_BufferQueue.Count == 0)
{
// When the delta between the time sent and the current tick latency time-window is greater than the max delta time
// plus the minimum delta time (a rough estimate of time to wait before we consider rate of change equal to zero),
@@ -593,8 +624,8 @@ public T Update(float deltaTime, double renderTime, double serverTime)
// Determine if we have reached our target
InterpolateState.TargetReached = IsApproximately(InterpolateState.CurrentValue, InterpolateState.Target.Value.Item, GetPrecision());
}
- else // If the target is reached and we have no more state updates, we want to check to see if we need to reset.
- if (InterpolateState.TargetReached && m_BufferQueue.Count == 0)
+ // If the target is reached and we have no more state updates, we want to check to see if we need to reset.
+ else if (InterpolateState.TargetReached && m_BufferQueue.Count == 0)
{
// When the delta between the time sent and the current tick latency time-window is greater than the max delta time
// plus the minimum delta time (a rough estimate of time to wait before we consider rate of change equal to zero),
diff --git a/com.unity.netcode.gameobjects/Runtime/Components/NetworkAnimator.cs b/com.unity.netcode.gameobjects/Runtime/Components/NetworkAnimator.cs
index 7d82872890..bf275ab3c3 100644
--- a/com.unity.netcode.gameobjects/Runtime/Components/NetworkAnimator.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Components/NetworkAnimator.cs
@@ -14,8 +14,8 @@ namespace Unity.Netcode.Components
{
internal class NetworkAnimatorStateChangeHandler : INetworkUpdateSystem
{
- private NetworkAnimator m_NetworkAnimator;
- private bool m_IsServer;
+ private readonly NetworkAnimator m_NetworkAnimator;
+ private readonly bool m_IsServer;
///
/// This removes sending RPCs from within RPCs when the
@@ -132,14 +132,14 @@ private struct AnimationUpdate
public NetworkAnimator.AnimationMessage AnimationMessage;
}
- private List m_SendAnimationUpdates = new List();
+ private readonly List m_SendAnimationUpdates = new List();
///
/// Invoked when a server needs to forwarding an update to the animation state
///
internal void SendAnimationUpdate(NetworkAnimator.AnimationMessage animationMessage, RpcParams rpcParams = default)
{
- m_SendAnimationUpdates.Add(new AnimationUpdate() { RpcParams = rpcParams, AnimationMessage = animationMessage });
+ m_SendAnimationUpdates.Add(new AnimationUpdate { RpcParams = rpcParams, AnimationMessage = animationMessage });
}
private struct ParameterUpdate
@@ -148,17 +148,17 @@ private struct ParameterUpdate
public NetworkAnimator.ParametersUpdateMessage ParametersUpdateMessage;
}
- private List m_SendParameterUpdates = new List();
+ private readonly List m_SendParameterUpdates = new List();
///
/// Invoked when a server needs to forwarding an update to the parameter state
///
internal void SendParameterUpdate(NetworkAnimator.ParametersUpdateMessage parametersUpdateMessage, RpcParams rpcParams = default)
{
- m_SendParameterUpdates.Add(new ParameterUpdate() { RpcParams = rpcParams, ParametersUpdateMessage = parametersUpdateMessage });
+ m_SendParameterUpdates.Add(new ParameterUpdate { RpcParams = rpcParams, ParametersUpdateMessage = parametersUpdateMessage });
}
- private List m_ProcessParameterUpdates = new List();
+ private readonly List m_ProcessParameterUpdates = new List();
internal void ProcessParameterUpdate(NetworkAnimator.ParametersUpdateMessage parametersUpdateMessage)
{
m_ProcessParameterUpdates.Add(parametersUpdateMessage);
@@ -171,31 +171,31 @@ private struct TriggerUpdate
public NetworkAnimator.AnimationTriggerMessage AnimationTriggerMessage;
}
- private List m_SendTriggerUpdates = new List();
+ private readonly List m_SendTriggerUpdates = new List();
///
/// Invoked when a server needs to forward an update to a Trigger state
///
internal void QueueTriggerUpdateToClient(NetworkAnimator.AnimationTriggerMessage animationTriggerMessage, RpcParams clientRpcParams = default)
{
- m_SendTriggerUpdates.Add(new TriggerUpdate() { RpcParams = clientRpcParams, AnimationTriggerMessage = animationTriggerMessage });
+ m_SendTriggerUpdates.Add(new TriggerUpdate { RpcParams = clientRpcParams, AnimationTriggerMessage = animationTriggerMessage });
}
internal void QueueTriggerUpdateToServer(NetworkAnimator.AnimationTriggerMessage animationTriggerMessage)
{
- m_SendTriggerUpdates.Add(new TriggerUpdate() { AnimationTriggerMessage = animationTriggerMessage, SendToServer = true });
+ m_SendTriggerUpdates.Add(new TriggerUpdate { AnimationTriggerMessage = animationTriggerMessage, SendToServer = true });
}
internal void DeregisterUpdate()
{
- NetworkUpdateLoop.UnregisterNetworkUpdate(this, NetworkUpdateStage.PreUpdate);
+ this.UnregisterNetworkUpdate(NetworkUpdateStage.PreUpdate);
}
internal NetworkAnimatorStateChangeHandler(NetworkAnimator networkAnimator)
{
m_NetworkAnimator = networkAnimator;
m_IsServer = networkAnimator.LocalNetworkManager.IsServer;
- NetworkUpdateLoop.RegisterNetworkUpdate(this, NetworkUpdateStage.PreUpdate);
+ this.RegisterNetworkUpdate(NetworkUpdateStage.PreUpdate);
}
}
@@ -213,7 +213,7 @@ public class NetworkAnimator : NetworkBehaviour, ISerializationCallbackReceiver
#endif
[Serializable]
- internal class TransitionStateinfo
+ internal class TransitionStateInfo
{
public bool IsCrossFadeExit;
public int Layer;
@@ -260,11 +260,8 @@ public enum AuthorityModes
///
public Animator Animator
{
- get { return m_Animator; }
- set
- {
- m_Animator = value;
- }
+ get => m_Animator;
+ set => m_Animator = value;
}
///
@@ -272,11 +269,11 @@ public Animator Animator
///
[HideInInspector]
[SerializeField]
- internal List TransitionStateInfoList;
+ internal List TransitionStateInfoList;
// Used to get the associated transition information required to synchronize late joining clients with transitions
// [Layer][DestinationState][TransitionStateInfo]
- private Dictionary> m_DestinationStateToTransitioninfo = new Dictionary>();
+ private readonly Dictionary> m_DestinationStateToTransitionInfo = new Dictionary>();
// Named differently to avoid serialization conflicts with NetworkBehaviour
internal NetworkManager LocalNetworkManager;
@@ -284,21 +281,15 @@ public Animator Animator
internal bool DistributedAuthorityMode;
///
- /// Builds the m_DestinationStateToTransitioninfo lookup table
+ /// Builds the lookup table
///
private void BuildDestinationToTransitionInfoTable()
{
foreach (var entry in TransitionStateInfoList)
{
- if (!m_DestinationStateToTransitioninfo.ContainsKey(entry.Layer))
- {
- m_DestinationStateToTransitioninfo.Add(entry.Layer, new Dictionary());
- }
- var destinationStateTransitionInfo = m_DestinationStateToTransitioninfo[entry.Layer];
- if (!destinationStateTransitionInfo.ContainsKey(entry.DestinationState))
- {
- destinationStateTransitionInfo.Add(entry.DestinationState, entry);
- }
+ m_DestinationStateToTransitionInfo.TryAdd(entry.Layer, new Dictionary());
+ var destinationStateTransitionInfo = m_DestinationStateToTransitionInfo[entry.Layer];
+ destinationStateTransitionInfo.TryAdd(entry.DestinationState, entry);
}
}
@@ -323,14 +314,14 @@ internal class AnimatorParametersListContainer
[SerializeField]
internal AnimatorParametersListContainer AnimatorParameterEntries;
- internal Dictionary AnimatorParameterEntryTable = new Dictionary();
+ private readonly Dictionary m_AnimatorParameterEntryTable = new Dictionary();
#if UNITY_EDITOR
[HideInInspector]
[SerializeField]
internal bool AnimatorParametersExpanded;
- internal Dictionary ParameterToNameLookup = new Dictionary();
+ private readonly Dictionary m_ParameterToNameLookup = new Dictionary();
private void ParseStateMachineStates(int layerIndex, ref AnimatorController animatorController, ref AnimatorStateMachine stateMachine)
{
@@ -371,7 +362,7 @@ private void ParseStateMachineStates(int layerIndex, ref AnimatorController anim
}
else if (transition.destinationState != null)
{
- var transitionInfo = new TransitionStateinfo()
+ var transitionInfo = new TransitionStateInfo()
{
Layer = layerIndex,
OriginatingState = animatorState.nameHash,
@@ -408,7 +399,7 @@ private void BuildTransitionStateInfoList()
return;
}
- TransitionStateInfoList = new List();
+ TransitionStateInfoList = new List();
var animControllerType = m_Animator.runtimeAnimatorController.GetType();
var animatorController = (AnimatorController)null;
@@ -433,7 +424,7 @@ private void BuildTransitionStateInfoList()
}
}
- internal void ProcessParameterEntries()
+ private void ProcessParameterEntries()
{
if (!Animator)
{
@@ -462,18 +453,18 @@ internal void ProcessParameterEntries()
var parameters = animatorController.parameters;
var parametersToRemove = new List();
- ParameterToNameLookup.Clear();
+ m_ParameterToNameLookup.Clear();
foreach (var parameter in parameters)
{
- ParameterToNameLookup.Add(parameter.nameHash, parameter);
+ m_ParameterToNameLookup.Add(parameter.nameHash, parameter);
}
// Rebuild the parameter entry table for the inspector view
- AnimatorParameterEntryTable.Clear();
+ m_AnimatorParameterEntryTable.Clear();
foreach (var parameterEntry in AnimatorParameterEntries.ParameterEntries)
{
// Check for removed parameters.
- if (!ParameterToNameLookup.ContainsKey(parameterEntry.NameHash))
+ if (!m_ParameterToNameLookup.ContainsKey(parameterEntry.NameHash))
{
parametersToRemove.Add(parameterEntry);
// Skip this removed entry
@@ -481,12 +472,9 @@ internal void ProcessParameterEntries()
}
// Build the list of known parameters
- if (!AnimatorParameterEntryTable.ContainsKey(parameterEntry.NameHash))
- {
- AnimatorParameterEntryTable.Add(parameterEntry.NameHash, parameterEntry);
- }
+ m_AnimatorParameterEntryTable.TryAdd(parameterEntry.NameHash, parameterEntry);
- var parameter = ParameterToNameLookup[parameterEntry.NameHash];
+ var parameter = m_ParameterToNameLookup[parameterEntry.NameHash];
parameterEntry.name = parameter.name;
parameterEntry.ParameterType = parameter.type;
}
@@ -498,9 +486,9 @@ internal void ProcessParameterEntries()
}
// Update any newly added parameters
- foreach (var parameterLookUp in ParameterToNameLookup)
+ foreach (var parameterLookUp in m_ParameterToNameLookup)
{
- if (!AnimatorParameterEntryTable.ContainsKey(parameterLookUp.Value.nameHash))
+ if (!m_AnimatorParameterEntryTable.ContainsKey(parameterLookUp.Value.nameHash))
{
var animatorParameterEntry = new AnimatorParameterEntry()
{
@@ -510,7 +498,7 @@ internal void ProcessParameterEntries()
Synchronize = true,
};
AnimatorParameterEntries.ParameterEntries.Add(animatorParameterEntry);
- AnimatorParameterEntryTable.Add(parameterLookUp.Value.nameHash, animatorParameterEntry);
+ m_AnimatorParameterEntryTable.Add(parameterLookUp.Value.nameHash, animatorParameterEntry);
}
}
}
@@ -602,7 +590,7 @@ public void NetworkSerialize(BufferSerializer serializer) where T : IReade
serializer.SerializeValue(ref NormalizedTime);
serializer.SerializeValue(ref Weight);
- // Cross fading includes the duration of the cross fade.
+ // Cross-fading includes the duration of the cross-fade.
if (CrossFade)
{
serializer.SerializeValue(ref Duration);
@@ -680,7 +668,7 @@ public void NetworkSerialize(BufferSerializer serializer) where T : IReade
/// Determines whether the is or based on the field.
/// Optionally, you can still derive from and override the method.
///
- /// or
+ /// True if this is server authoritative, false otherwise
public bool IsServerAuthoritative()
{
return OnIsServerAuthoritative();
@@ -706,7 +694,6 @@ protected virtual bool OnIsServerAuthoritative()
private int[] m_TransitionHash;
private int[] m_AnimationHash;
private float[] m_LayerWeights;
- private static byte[] s_EmptyArray = new byte[] { };
private List m_ParametersToUpdate;
private RpcParams m_RpcParams;
private IGroupRpcTarget m_TargetGroup;
@@ -781,14 +768,14 @@ protected virtual void Awake()
if (!m_Animator)
{
#if !UNITY_EDITOR
- Debug.LogError($"{nameof(NetworkAnimator)} {name} does not have an {nameof(UnityEngine.Animator)} assigned to it. The {nameof(NetworkAnimator)} will not initialize properly.");
+ Debug.LogWarning($"{nameof(NetworkAnimator)} {name} does not have an {nameof(UnityEngine.Animator)} assigned to it. The {nameof(NetworkAnimator)} will not initialize properly.");
#endif
return;
}
foreach (var parameterEntry in AnimatorParameterEntries.ParameterEntries)
{
- AnimatorParameterEntryTable.TryAdd(parameterEntry.NameHash, parameterEntry);
+ m_AnimatorParameterEntryTable.TryAdd(parameterEntry.NameHash, parameterEntry);
}
int layers = m_Animator.layerCount;
@@ -814,10 +801,7 @@ protected virtual void Awake()
// AnimationMessage.
m_AnimationMessage.AnimationStates.Add(new AnimationState());
float layerWeightNow = m_Animator.GetLayerWeight(layer);
- if (layerWeightNow != m_LayerWeights[layer])
- {
- m_LayerWeights[layer] = layerWeightNow;
- }
+ m_LayerWeights[layer] = layerWeightNow;
}
// The total initialization size calculated for the m_ParameterWriter write buffer.
@@ -835,9 +819,9 @@ protected virtual void Awake()
{
var parameter = parameters[i];
var synchronizeParameter = true;
- if (AnimatorParameterEntryTable.ContainsKey(parameter.nameHash))
+ if (m_AnimatorParameterEntryTable.TryGetValue(parameter.nameHash, out var entry))
{
- synchronizeParameter = AnimatorParameterEntryTable[parameter.nameHash].Synchronize;
+ synchronizeParameter = entry.Synchronize;
}
var cacheParam = new AnimatorParamCache
@@ -863,8 +847,6 @@ protected virtual void Awake()
var valueBool = m_Animator.GetBool(cacheParam.Hash);
UnsafeUtility.WriteArrayElement(cacheParam.Value, 0, valueBool);
break;
- default:
- break;
}
}
@@ -986,12 +968,12 @@ private void WriteSynchronizationData(ref BufferSerializer serializer) whe
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
+ // 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
+ // handled by cross-fading between the late joining client's current layer's AnimationState
// and the transition's destination AnimationState.
if (isInTransition)
{
@@ -1013,16 +995,14 @@ private void WriteSynchronizationData(ref BufferSerializer serializer) whe
}
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))
+ // Check if this transition can be synchronized using cross-fading
+ if (m_DestinationStateToTransitionInfo.TryGetValue(layer, out var layerTransitions))
{
- if (m_DestinationStateToTransitioninfo[layer].ContainsKey(nextState.shortNameHash))
+ if (layerTransitions.TryGetValue(nextState.shortNameHash, out var transitionInfo))
{
- 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;
+ stateHash = transitionInfo.OriginatingState;
+ // Set the destination state to cross-fade to from the originating state
+ animationState.DestinationStateHash = transitionInfo.DestinationState;
}
}
}
@@ -1070,7 +1050,7 @@ protected override void OnSynchronize(ref BufferSerializer serializer)
///
/// Checks for animation state changes in:
/// -Layer weights
- /// -Cross fades
+ /// -Cross-fades
/// -Transitions
/// -Layer AnimationStates
///
@@ -1104,7 +1084,7 @@ private void CheckForStateChange(int layer)
{
m_TransitionHash[layer] = nt.fullPathHash;
m_AnimationHash[layer] = 0;
- // Next state is the destination state for cross fade
+ // Next state is the destination state for cross-fade
animState.DestinationStateHash = nt.fullPathHash;
animState.CrossFade = true;
animState.Transition = true;
@@ -1113,12 +1093,13 @@ private void CheckForStateChange(int layer)
stateChangeDetected = true;
//Debug.Log($"[Cross-Fade] To-Hash: {nt.fullPathHash} | TI-Duration: ({tt.duration}) | TI-Norm: ({tt.normalizedTime}) | From-Hash: ({m_AnimationHash[layer]}) | SI-FPHash: ({st.fullPathHash}) | SI-Norm: ({st.normalizedTime})");
}
- // If we are not transitioned into the "any state" and the animator transition isn't a full path hash (layer to layer) and our pre-built destination state to transition does not contain the
- // current layer (i.e. transitioning into a state from another layer) =or= we do contain the layer and the layer contains state to transition to is contained within our pre-built destination
- // state then we can handle this transition as a non-cross fade state transition between layers.
- // Otherwise, if we don't enter into this then this is a "trigger transition to some state that is now being transitioned back to the Idle state via trigger" or "Dual Triggers" IDLE<-->State.
- else if (!tt.anyState && tt.fullPathHash != m_TransitionHash[layer] && (!m_DestinationStateToTransitioninfo.ContainsKey(layer) ||
- (m_DestinationStateToTransitioninfo.ContainsKey(layer) && m_DestinationStateToTransitioninfo[layer].ContainsKey(nt.fullPathHash))))
+ // Handle as a non-cross-fade transition when:
+ // - not an "any state" transition and this is a new transition on this layer
+ // - the layer is either absent from the lookup table (cross-layer transition) or its destination state is present
+ // Skipping this block means we are in a "dual trigger" scenario where a trigger transitions
+ // to a state that is immediately transitioned back via another trigger (e.g. IDLE <--> State).
+ else if (!tt.anyState && tt.fullPathHash != m_TransitionHash[layer] && (!m_DestinationStateToTransitionInfo.TryGetValue(layer, out var layerTransitions) ||
+ layerTransitions.ContainsKey(nt.fullPathHash)))
{
// first time in this transition for this layer
m_TransitionHash[layer] = tt.fullPathHash;
@@ -1128,7 +1109,7 @@ private void CheckForStateChange(int layer)
animState.CrossFade = false;
animState.Transition = true;
animState.NormalizedTime = tt.normalizedTime;
- if (m_DestinationStateToTransitioninfo.ContainsKey(layer) && m_DestinationStateToTransitioninfo[layer].ContainsKey(nt.fullPathHash))
+ if (layerTransitions != null)
{
animState.DestinationStateHash = nt.fullPathHash;
}
@@ -1189,9 +1170,6 @@ internal void CheckForAnimatorChanges()
// This sends updates only if a layer's state has changed
for (int layer = 0; layer < m_Animator.layerCount; layer++)
{
- AnimatorStateInfo st = m_Animator.GetCurrentAnimatorStateInfo(layer);
- var totalSpeed = st.speed * st.speedMultiplier;
- var adjustedNormalizedMaxTime = totalSpeed > 0.0f ? 1.0f / totalSpeed : 0.0f;
CheckForStateChange(layer);
}
@@ -1202,8 +1180,7 @@ internal void CheckForAnimatorChanges()
{
SendAnimStateRpc(m_AnimationMessage);
}
- else
- if (!IsServer && IsOwner)
+ else if (!IsServer && IsOwner)
{
SendServerAnimStateRpc(m_AnimationMessage);
}
@@ -1337,8 +1314,8 @@ private unsafe bool CheckParametersChanged()
}
///
- /// Writes all of the Animator's parameters
- /// This uses the m_ParametersToUpdate list to write out only
+ /// Writes all the Animator's parameters
+ /// This uses the list to write out only
/// the parameters that have changed
///
private unsafe void WriteParameters(ref FastBufferWriter writer)
@@ -1368,8 +1345,7 @@ private unsafe void WriteParameters(ref FastBufferWriter writer)
BytePacker.WriteValuePacked(writer, (uint)valueInt);
}
}
- else // Note: Triggers are treated like boolean values
- if (cacheValue.Type == AnimationParamEnumWrapper.AnimatorControllerParameterBool)
+ else if (cacheValue.Type == AnimationParamEnumWrapper.AnimatorControllerParameterBool)
{
var valueBool = m_Animator.GetBool(hash);
fixed (void* value = cacheValue.Value)
@@ -1401,6 +1377,13 @@ private unsafe void ReadParameters(FastBufferReader reader)
while (totalParametersRead < totalParametersToRead)
{
ByteUnpacker.ReadValuePacked(reader, out uint parameterIndex);
+
+ // Do bounds check prior to getting the element as a reference at that index.
+ if (parameterIndex >= m_CachedAnimatorParameters.Length)
+ {
+ NetworkManager.Log.ErrorServer(new Logging.Context(LogLevel.Error, $"[{nameof(NetworkAnimator)}][{name}] Invalid index of {parameterIndex} was received when there are only {m_CachedAnimatorParameters.Length} parameters. Ignoring the remainger of this {nameof(ParametersUpdateMessage)}!"));
+ return;
+ }
ref var cacheValue = ref UnsafeUtility.ArrayElementAsRef(m_CachedAnimatorParameters.GetUnsafePtr(), (int)parameterIndex);
var hash = cacheValue.Hash;
if (cacheValue.Type == AnimationParamEnumWrapper.AnimatorControllerParameterInt)
@@ -1453,7 +1436,7 @@ internal unsafe void UpdateParameters(ref ParametersUpdateMessage parametersUpda
///
/// Applies the AnimationState state to the Animator
///
- internal void UpdateAnimationState(AnimationState animationState)
+ private void UpdateAnimationState(AnimationState animationState)
{
// Handle updating layer weights first.
if (animationState.Layer < m_LayerWeights.Length)
@@ -1475,21 +1458,17 @@ internal void UpdateAnimationState(AnimationState animationState)
// If it is a transition, then we are synchronizing transitions in progress when a client late joins
if (animationState.Transition && !animationState.CrossFade)
{
- // We should have all valid entries for any animation state transition update
- // Verify the AnimationState's assigned Layer exists
- if (m_DestinationStateToTransitioninfo.ContainsKey(animationState.Layer))
+ // At this point all entries in the lookup table should be valid.
+ // Look up the transition info for this layer and destination state.
+ if (m_DestinationStateToTransitionInfo.TryGetValue(animationState.Layer, out var layerTransitions))
{
- // Verify the inner-table has the destination AnimationState name hash
- if (m_DestinationStateToTransitioninfo[animationState.Layer].ContainsKey(animationState.DestinationStateHash))
+ if (layerTransitions.TryGetValue(animationState.DestinationStateHash, out var transitionInfo))
{
- // Make sure we are on the originating/starting state we are going to cross fade into
+ // Make sure we are on the originating/starting state we are going to cross-fade into
if (currentState.shortNameHash == animationState.StateHash)
{
- // Get the transition state information
- var transitionStateInfo = m_DestinationStateToTransitioninfo[animationState.Layer][animationState.DestinationStateHash];
-
- // Cross fade from the current to the destination state for the transitions duration while starting at the server's current normalized time of the transition
- m_Animator.CrossFade(transitionStateInfo.DestinationState, transitionStateInfo.TransitionDuration, transitionStateInfo.Layer, 0.0f, animationState.NormalizedTime);
+ // Cross-fade from the current to the destination state for the transitions duration while starting at the server's current normalized time of the transition
+ m_Animator.CrossFade(transitionInfo.DestinationState, transitionInfo.TransitionDuration, transitionInfo.Layer, 0.0f, animationState.NormalizedTime);
}
else if (LocalNetworkManager.LogLevel == LogLevel.Developer)
{
@@ -1526,7 +1505,7 @@ internal void UpdateAnimationState(AnimationState animationState)
/// The server sets its local parameters and then forwards the message to the remaining clients
///
[Rpc(SendTo.Server, AllowTargetOverride = true, InvokePermission = RpcInvokePermission.Owner)]
- private unsafe void SendServerParametersUpdateRpc(ParametersUpdateMessage parametersUpdate, RpcParams rpcParams = default)
+ private void SendServerParametersUpdateRpc(ParametersUpdateMessage parametersUpdate, RpcParams rpcParams = default)
{
if (IsServerAuthoritative())
{
@@ -1708,9 +1687,6 @@ internal void SendServerAnimTriggerRpc(AnimationTriggerMessage animationTriggerM
}
}
- ///
- /// See above
- ///
private void InternalSetTrigger(int hash, bool isSet = true)
{
m_Animator.SetBool(hash, isSet);
@@ -1721,6 +1697,7 @@ private void InternalSetTrigger(int hash, bool isSet = true)
/// to forward a trigger to a client
///
/// the payload containing the trigger data to apply
+ /// Defined as it's used to send the RPC to be invoked on this client
[Rpc(SendTo.NotAuthority, AllowTargetOverride = true, InvokePermission = RpcInvokePermission.Owner)]
internal void SendAnimTriggerRpc(AnimationTriggerMessage animationTriggerMessage, RpcParams rpcParams = default)
{
@@ -1732,7 +1709,7 @@ internal void SendAnimTriggerRpc(AnimationTriggerMessage animationTriggerMessage
/// a trigger to a client
///
/// the payload containing the trigger data to apply
- /// unused
+ /// used to send the RPC to be invoked on this client
[Rpc(SendTo.NotServer, AllowTargetOverride = true)]
internal void SendClientAnimTriggerRpc(AnimationTriggerMessage animationTriggerMessage, RpcParams rpcParams = default)
{
@@ -1775,13 +1752,11 @@ public void SetTrigger(int hash, bool setTrigger = true)
{
if (IsServer)
{
- /// as to why we queue
m_NetworkAnimatorStateChangeHandler.QueueTriggerUpdateToClient(animTriggerMessage);
InternalSetTrigger(hash, setTrigger);
}
else
{
- /// as to why we queue
m_NetworkAnimatorStateChangeHandler.QueueTriggerUpdateToServer(animTriggerMessage);
if (!IsServerAuthoritative())
{
diff --git a/com.unity.netcode.gameobjects/Runtime/Components/NetworkDeltaPosition.cs b/com.unity.netcode.gameobjects/Runtime/Components/NetworkDeltaPosition.cs
index a780a07230..3bae7eded3 100644
--- a/com.unity.netcode.gameobjects/Runtime/Components/NetworkDeltaPosition.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Components/NetworkDeltaPosition.cs
@@ -11,7 +11,14 @@ namespace Unity.Netcode.Components
[Serializable]
public struct NetworkDeltaPosition : INetworkSerializable
{
- internal const float MaxDeltaBeforeAdjustment = 64f;
+ ///
+ /// How far the delta may grow before it is folded into the base position.
+ ///
+ ///
+ /// This determines the transmitted position resolution, since a half float's step size grows with its
+ /// magnitude. Keeping the delta small keeps that step small: at 2 the coarsest step is roughly 1mm.
+ ///
+ internal const float MaxDeltaBeforeAdjustment = 2f;
///
/// The HalfVector3 used to synchronize the delta in position
@@ -138,14 +145,29 @@ public void UpdateFrom(ref Vector3 vector3, int networkTick)
{
CollapsedDeltaIntoBase = false;
NetworkTick = networkTick;
- DeltaPosition = (vector3 + PrecisionLossDelta) - CurrentBasePosition;
for (int i = 0; i < HalfVector3.Length; i++)
{
if (HalfVector3.AxisToSynchronize[i])
{
+ var rawDelta = vector3[i] - CurrentBasePosition[i];
+
+ // Adding the previous rounding loss back in keeps the average position accurate while the
+ // value is moving, but it also changes the value being sent. Once the value stops moving
+ // that is all it does, which makes a stationary object appear to oscillate.
+ var movedSinceLastSend = Mathf.Abs(vector3[i] - PreviousPosition[i]);
+ var applyPrecisionLoss = movedSinceLastSend >= HalfPrecisionQuantum(rawDelta);
+
+ DeltaPosition[i] = applyPrecisionLoss ? rawDelta + PrecisionLossDelta[i] : rawDelta;
+
HalfVector3.Axis[i] = math.half(DeltaPosition[i]);
HalfDeltaConvertedBack[i] = Mathf.HalfToFloat(HalfVector3.Axis[i].value);
- PrecisionLossDelta[i] = DeltaPosition[i] - HalfDeltaConvertedBack[i];
+
+ // Left unchanged when skipped so it is still applied once movement resumes.
+ if (applyPrecisionLoss)
+ {
+ PrecisionLossDelta[i] = DeltaPosition[i] - HalfDeltaConvertedBack[i];
+ }
+
if (Mathf.Abs(HalfDeltaConvertedBack[i]) >= MaxDeltaBeforeAdjustment)
{
CurrentBasePosition[i] += HalfDeltaConvertedBack[i];
@@ -165,6 +187,26 @@ public void UpdateFrom(ref Vector3 vector3, int networkTick)
}
}
+ ///
+ /// The smallest change a half float can represent at the magnitude of the value passed in.
+ ///
+ /// The value to get the step size for.
+ /// The distance to the next representable half float value.
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ internal static float HalfPrecisionQuantum(float value)
+ {
+ // The step size is symmetric about zero, so the sign is dropped.
+ var magnitude = (ushort)(math.half(value).value & 0x7FFF);
+
+ // Guard only: stepping past the largest finite half float would give infinity.
+ if (magnitude >= 0x7BFF)
+ {
+ return MaxDeltaBeforeAdjustment;
+ }
+
+ return Mathf.HalfToFloat((ushort)(magnitude + 1)) - Mathf.HalfToFloat(magnitude);
+ }
+
///
/// Constructor
///
diff --git a/com.unity.netcode.gameobjects/Runtime/Components/NetworkRigidBodyBase.cs b/com.unity.netcode.gameobjects/Runtime/Components/NetworkRigidBodyBase.cs
index 0d0de9afa8..7df6af4e59 100644
--- a/com.unity.netcode.gameobjects/Runtime/Components/NetworkRigidBodyBase.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Components/NetworkRigidBodyBase.cs
@@ -2,6 +2,7 @@
using System.Runtime.CompilerServices;
using UnityEngine;
+
namespace Unity.Netcode.Components
{
///
@@ -571,7 +572,7 @@ private void InternalMoveRotation2D(Quaternion rotation)
{
var quaternion = Quaternion.identity;
var angles = quaternion.eulerAngles;
- angles.z = m_InternalRigidbody2D.rotation;
+ angles.z = rotation.z;
quaternion.eulerAngles = angles;
m_InternalRigidbody2D.MoveRotation(quaternion);
}
@@ -845,6 +846,28 @@ public void SetIsKinematic(bool isKinematic)
PostSetIsKinematic();
}
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ private bool HasInterpolationTypeSet(InterpolationTypes interpolationType)
+ {
+#if COM_UNITY_MODULES_PHYSICS && COM_UNITY_MODULES_PHYSICS2D
+ if (m_IsRigidbody2D)
+ {
+ return interpolationType == InterpolationTypes.Extrapolate ? m_InternalRigidbody2D.interpolation == RigidbodyInterpolation2D.Extrapolate : m_InternalRigidbody2D.interpolation == RigidbodyInterpolation2D.Interpolate;
+ }
+ else
+ {
+ return interpolationType == InterpolationTypes.Extrapolate ? m_InternalRigidbody.interpolation == RigidbodyInterpolation.Extrapolate : m_InternalRigidbody.interpolation == RigidbodyInterpolation.Interpolate;
+ }
+#endif
+#if COM_UNITY_MODULES_PHYSICS && !COM_UNITY_MODULES_PHYSICS2D
+ return interpolationType == InterpolationTypes.Extrapolate ? m_InternalRigidbody.interpolation == RigidbodyInterpolation.Extrapolate : m_InternalRigidbody.interpolation == RigidbodyInterpolation.Interpolate;
+#endif
+#if !COM_UNITY_MODULES_PHYSICS && COM_UNITY_MODULES_PHYSICS2D
+ return interpolationType == InterpolationTypes.Extrapolate ? m_InternalRigidbody2D.interpolation == RigidbodyInterpolation2D.Extrapolate : m_InternalRigidbody2D.interpolation == RigidbodyInterpolation2D.Interpolate;
+#endif
+ }
+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void PostSetIsKinematic()
{
@@ -853,26 +876,29 @@ private void PostSetIsKinematic()
{
return;
}
+
if (UseRigidBodyForMotion)
{
- // Only if the NetworkTransform is set to interpolate do we need to check for extrapolation
- if (NetworkTransform.Interpolate && m_OriginalInterpolation == InterpolationTypes.Extrapolate)
+ // Exit early if the original interpolation type is not set to extrapolate or NetworkTransform interpolate is disabled
+ if (m_OriginalInterpolation != InterpolationTypes.Extrapolate || !NetworkTransform.Interpolate)
{
- if (IsKinematic())
- {
- // If not already set to interpolate then set the Rigidbody to interpolate
- if (m_InternalRigidbody.interpolation == RigidbodyInterpolation.Extrapolate)
- {
- // Sleep until the next fixed update when switching from extrapolation to interpolation
- SleepRigidbody();
- SetInterpolation(InterpolationTypes.Interpolate);
- }
- }
- else
- {
- // Switch it back to the original interpolation if non-kinematic (doesn't require sleep).
- SetInterpolation(m_OriginalInterpolation);
- }
+ return;
+ }
+
+ // Otherwise, if this is the active physics object
+ if (!IsKinematic())
+ {
+ // switch it back to the original interpolation and exit early
+ SetInterpolation(m_OriginalInterpolation);
+ return;
+ }
+
+ // If the Rigidbody or Rigidbody2D is currently configured to extrapolate
+ if (HasInterpolationTypeSet(InterpolationTypes.Extrapolate))
+ {
+ // sleep until the next fixed update when switching from extrapolation to interpolation
+ SleepRigidbody();
+ SetInterpolation(InterpolationTypes.Interpolate);
}
}
else
diff --git a/com.unity.netcode.gameobjects/Runtime/Components/NetworkTransform.cs b/com.unity.netcode.gameobjects/Runtime/Components/NetworkTransform.cs
index 3ca9093b34..9ac503a926 100644
--- a/com.unity.netcode.gameobjects/Runtime/Components/NetworkTransform.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Components/NetworkTransform.cs
@@ -24,6 +24,18 @@ public class NetworkTransform : NetworkBehaviour
[HideInInspector]
[SerializeField]
internal bool NetworkTransformExpanded;
+
+ [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+ private static void ResetStaticsOnLoad()
+ {
+ CurrentTick = 0;
+ TrackStateUpdateId = false;
+ AssignDefaultInterpolationType = false;
+ DefaultInterpolationType = default;
+ s_NetworkTickRegistration = new Dictionary();
+ InterpolationBufferTickOffset = 0;
+ s_TickSynchPosition = 0;
+ }
#endif
internal enum Axis { X, Y, Z }
@@ -1124,7 +1136,7 @@ public enum InterpolationTypes
/// Uses a 1 to 2 phase interpolation approach where:
///
/// - The first phase lerps from the previous state update value to the next state update value.
- /// - The second phase (optional) performs lerp smoothing where the current respective transform value is lerped towards the result of the first phase at a rate of 1.0 minus the respective maximum interpolation time.
+ /// - The second phase (optional) performs lerp smoothing where the current respective transform value is lerped towards the result of the first phase at a frame rate independent rate determined by the respective maximum interpolation time.
///
///
///
@@ -1144,7 +1156,7 @@ public enum InterpolationTypes
/// Uses a 1 to 2 phase smooth dampening approach where:
///
/// - The first phase smooth dampens towards the current tick state update being processed by the accumulated delta time relative to the time to target.
- /// - The second phase (optional) performs lerp smoothing where the current respective transform value is lerped towards the result of the first phase at a rate of delta time divided by the respective max interpolation time.
+ /// - The second phase (optional) performs lerp smoothing where the current respective transform value is lerped towards the result of the first phase at a frame rate independent rate determined by the respective maximum interpolation time.
///
///
///
@@ -1224,7 +1236,11 @@ public enum InterpolationTypes
/// Controls position interpolation smoothing.
///
///
- /// When enabled, the will apply a final lerping pass where the "t" parameter is calculated by dividing the frame time divided by the .
+ /// When enabled, the will apply a final lerping pass towards
+ /// the interpolated result at a rate determined by .
+ /// This smoothing pass is frame rate independent under and
+ /// . keeps its
+ /// original frame rate dependent smoothing, so the same value does not produce the same result there.
///
public bool PositionLerpSmoothing = true;
private bool m_PreviousPositionLerpSmoothing;
@@ -1245,7 +1261,11 @@ public enum InterpolationTypes
/// Controls rotation interpolation smoothing.
///
///
- /// When enabled, the will apply a final lerping pass where the "t" parameter is calculated by dividing the frame time divided by the .
+ /// When enabled, the will apply a final lerping pass towards
+ /// the interpolated result at a rate determined by .
+ /// This smoothing pass is frame rate independent under and
+ /// . keeps its
+ /// original frame rate dependent smoothing, so the same value does not produce the same result there.
///
public bool RotationLerpSmoothing = true;
private bool m_PreviousRotationLerpSmoothing;
@@ -1266,7 +1286,11 @@ public enum InterpolationTypes
/// Controls scale interpolation smoothing.
///
///
- /// When enabled, the will apply a final lerping pass where the "t" parameter is calculated by dividing the frame time divided by the .
+ /// When enabled, the will apply a final lerping pass towards
+ /// the interpolated result at a rate determined by .
+ /// This smoothing pass is frame rate independent under and
+ /// . keeps its
+ /// original frame rate dependent smoothing, so the same value does not produce the same result there.
///
public bool ScaleLerpSmoothing = true;
private bool m_PreviousScaleLerpSmoothing;
@@ -1361,7 +1385,7 @@ public enum AuthorityModes
///
/// When set each state update will contain a state identifier
///
- internal static bool TrackStateUpdateId = false;
+ internal static bool TrackStateUpdateId;
///
/// Enabled by default.
@@ -2062,19 +2086,6 @@ private void TryCommitTransform(bool synchronize = false, bool settingState = fa
childNetworkTransform.OnNetworkTick(true);
}
}
-
- // Synchronize any parented children with the parent's motion
- foreach (var child in m_ParentedChildren)
- {
- // Synchronize any nested NetworkTransforms of the child with the parent's
- foreach (var childNetworkTransform in child.NetworkTransforms)
- {
- if (childNetworkTransform.CanCommitToTransform)
- {
- childNetworkTransform.OnNetworkTick(true);
- }
- }
- }
}
}
}
@@ -2221,17 +2232,15 @@ private bool CheckForStateChange(ref NetworkTransformState networkState, bool is
// values are applied.
var hasParentNetworkObject = false;
- var parentNetworkObject = (NetworkObject)null;
-
// If the NetworkObject belonging to this NetworkTransform instance has a parent
// (i.e. this handles nested NetworkTransforms under a parent at some layer above)
if (NetworkObject.transform.parent != null)
{
- parentNetworkObject = NetworkObject.transform.parent.GetComponent();
+ var parentNetworkObject = NetworkObject.transform.parent.GetComponent();
// In-scene placed NetworkObjects parented under a GameObject with no
// NetworkObject preserve their lossyScale when synchronizing.
- if (parentNetworkObject == null && NetworkObject.IsSceneObject != false)
+ if (parentNetworkObject == null && NetworkObject.InScenePlaced)
{
hasParentNetworkObject = true;
}
@@ -2518,8 +2527,8 @@ private bool CheckForStateChange(ref NetworkTransformState networkState, bool is
}
}
}
- else // Just apply the full local scale when synchronizing
- if (SynchronizeScale)
+ // Just apply the full local scale when synchronizing
+ else if (SynchronizeScale)
{
var localScale = CachedTransform.localScale;
if (!UseHalfFloatPrecision)
@@ -3363,19 +3372,6 @@ private void OnNetworkStateChanged(NetworkTransformState oldState, NetworkTransf
childNetworkTransform.OnNetworkTick(true);
}
}
-
- // Synchronize any parented children with the parent's motion
- foreach (var child in m_ParentedChildren)
- {
- // Synchronize any nested NetworkTransforms of the child with the parent's
- foreach (var childNetworkTransform in child.NetworkTransforms)
- {
- if (childNetworkTransform.CanCommitToTransform)
- {
- childNetworkTransform.OnNetworkTick(true);
- }
- }
- }
}
// Provide notifications when the state has been updated
@@ -3504,8 +3500,8 @@ private void NonAuthorityFinalizeSynchronization()
child.InternalInitialization();
}
}
- else // Otherwise, just run through standard synchronization of this instance
- if (!CanCommitToTransform)
+ // Otherwise, just run through standard synchronization of this instance
+ else if (!CanCommitToTransform)
{
ApplySynchronization();
InternalInitialization();
@@ -3634,8 +3630,6 @@ internal override void InternalOnNetworkPreSpawn(ref NetworkManager networkManag
///
public override void OnNetworkSpawn()
{
- m_ParentedChildren.Clear();
-
Initialize();
if (CanCommitToTransform && !SwitchTransformSpaceWhenParented)
@@ -3647,7 +3641,6 @@ public override void OnNetworkSpawn()
private void CleanUpOnDestroyOrDespawn()
{
- m_ParentedChildren.Clear();
#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
var forUpdate = !m_UseRigidbodyForMotion;
#else
@@ -3722,6 +3715,38 @@ private void ResetInterpolatedStateToCurrentAuthoritativeState()
m_ScaleInterpolator.ResetTo(transform.parent, transform.localScale, serverTime);
}
+ ///
+ /// Determines if this has any instances that are non-authority and are updated during the same update stage.
+ ///
+ ///
+ /// See to better understand how the parameter is used to determine which update stage to check for non-authority instances.
+ ///
+ /// true to check the instances updated during the standard update and false to check the instances updated during the fixed update.
+ /// true if a non-authority NetworkTransform exists on this NetworkObject and false if there are none.
+ private bool HasNonAuthorityNetworkTransform(bool forUpdate)
+ {
+ var networkTransforms = NetworkObject.NetworkTransforms;
+ for (int i = 0; i < networkTransforms.Count; i++)
+ {
+ var networkTransform = networkTransforms[i];
+#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
+ // If the update stages don't match, then skip this instance.
+ // Reference:
+ // forUpdate is true for the standard update and false for the fixed update.
+ // m_UseRigidbodyForMotion is false for the standard update and true for the fixed update.
+ if (forUpdate == networkTransform.m_UseRigidbodyForMotion)
+ {
+ continue;
+ }
+#endif
+ if (!(networkTransform.IsServerAuthoritative() ? networkTransform.IsServer : networkTransform.IsOwner))
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+
///
/// The internal initialization method to allow for internal API adjustments
///
@@ -3784,8 +3809,12 @@ private void InternalInitialization(bool isOwnershipChange = false)
if (CanCommitToTransform)
{
- // Make sure authority doesn't get added to updates (no need to do this on the authority side)
- m_CachedNetworkManager.NetworkTransformRegistration(NetworkObject, forUpdate, false);
+ // If there are no non-authority NetworkTransform instances on this NetworkObject using this update, then remove this instance from the NetworkManager's update list.
+ // Otherwise, we need to keep it registered for updates so the non-authority instances will process their received state updates and apply them to the transform.
+ if (!HasNonAuthorityNetworkTransform(forUpdate))
+ {
+ m_CachedNetworkManager.NetworkTransformRegistration(NetworkObject, forUpdate, false);
+ }
if (UseHalfFloatPrecision)
{
m_HalfPositionState = new NetworkDeltaPosition(currentPosition, m_CachedNetworkManager.ServerTime.Tick, math.bool3(SyncPositionX, SyncPositionY, SyncPositionZ));
@@ -3861,7 +3890,6 @@ protected override void OnOwnershipChanged(ulong previous, ulong current)
}
internal bool IsNested;
- private List m_ParentedChildren = new List();
private bool m_IsFirstNetworkTransform;
@@ -4250,14 +4278,13 @@ internal BufferedLinearInterpolatorQuaternion GetRotationInterpolator()
// Non-Authority
private void UpdateInterpolation()
{
- // Use the local time because:
- // Client-Server:
- // Local time is server time on a host or server.
- // Local time on clients takes latency into consideration.
- // Distributed authority:
- // Local time is used by the authority.
- // Local time on non-authority takes latency into consid]eration.
- var timeSystem = m_CachedNetworkManager.LocalTime;
+ // Use the server time, since that is the clock the states being interpolated between are stamped on
+ // (a state's SentTime is derived from its NetworkTick). Deriving the render time from LocalTime
+ // subtracts the tick latency from a clock that already leads ServerTime by roughly that much, which
+ // leaves the render time at or ahead of the newest state that can exist and starves the interpolator.
+ // Measuring from ServerTime is also self correcting, as the tick latency grows with the round trip
+ // time. This is a no-op on a host or server, where both clocks are the same.
+ var timeSystem = m_CachedNetworkManager.ServerTime;
var currentTime = timeSystem.Time;
#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
var cachedDeltaTime = m_UseRigidbodyForMotion ? m_CachedNetworkManager.RealTimeProvider.FixedDeltaTime : m_CachedNetworkManager.RealTimeProvider.DeltaTime;
@@ -4694,7 +4721,7 @@ internal static void UpdateNetworkTick(NetworkManager networkManager)
/// The default value is 1 tick (plus the tick latency). When running on a local network, reducing this to 0 is recommended.
///
///
- public static int InterpolationBufferTickOffset = 0;
+ public static int InterpolationBufferTickOffset;
internal static float GetTickLatency(NetworkManager networkManager)
{
if (networkManager.IsListening)
@@ -4721,7 +4748,10 @@ internal static float GetTickLatencyInSeconds(NetworkManager networkManager)
{
if (networkManager.IsListening)
{
- return (float)networkManager.LocalTime.TimeTicksAgo(networkManager.NetworkTimeSystem.TickLatency + InterpolationBufferTickOffset).Time;
+ // The number of ticks the interpolators run behind, as a duration. This is not a point in time:
+ // it does not grow as the session runs.
+ var ticksBehind = networkManager.NetworkTimeSystem.TickLatency + InterpolationBufferTickOffset;
+ return (float)(ticksBehind * networkManager.ServerTime.FixedDeltaTimeAsDouble);
}
return 0f;
}
@@ -4799,6 +4829,7 @@ public NetworkTransformTickRegistration(NetworkManager networkManager)
}
}
}
+
private static int s_TickSynchPosition;
private int m_NextTickSync;
diff --git a/com.unity.netcode.gameobjects/Runtime/Components/QuaternionCompressor.cs b/com.unity.netcode.gameobjects/Runtime/Components/QuaternionCompressor.cs
index f4d9b25dd2..3c338a2a84 100644
--- a/com.unity.netcode.gameobjects/Runtime/Components/QuaternionCompressor.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Components/QuaternionCompressor.cs
@@ -4,7 +4,7 @@
namespace Unity.Netcode
{
///
- /// A Smallest Three Quaternion Compressor Implementation
+ /// The Smallest Three Quaternion Compressor Implementation
///
///
/// Explanation of why "The smallest three":
@@ -26,14 +26,14 @@ public static class QuaternionCompressor
// We can further improve the encoding compression by dividing k_SqrtTwoOverTwo into 1.0f and multiplying that
// by the precision mask (minor reduction of runtime calculations)
- private const float k_CompressionEcodingMask = (1.0f / k_SqrtTwoOverTwoEncoding) * k_PrecisionMask;
+ private const float k_CompressionEncodingMask = (1.0f / k_SqrtTwoOverTwoEncoding) * k_PrecisionMask;
// Used to shift the negative bit to the 10th bit position when compressing and encoding
private const ushort k_ShiftNegativeBit = 9;
// We can do the same for our decoding and decompression by dividing k_PrecisionMask into 1.0 and multiplying
// that by k_SqrtTwoOverTwo (minor reduction of runtime calculations)
- private const float k_DcompressionDecodingMask = (1.0f / k_PrecisionMask) * k_SqrtTwoOverTwoEncoding;
+ private const float k_DecompressionDecodingMask = (1.0f / k_PrecisionMask) * k_SqrtTwoOverTwoEncoding;
// The sign bit position (10th bit) used when decompressing and decoding
private const ushort k_NegShortBit = 0x200;
@@ -42,9 +42,6 @@ public static class QuaternionCompressor
private const ushort k_True = 1;
private const ushort k_False = 0;
- // Used to store the absolute value of the 4 quaternion elements
- private static Quaternion s_QuatAbsValues = Quaternion.identity;
-
///
/// Compresses a Quaternion into an unsigned integer
///
@@ -54,38 +51,31 @@ public static class QuaternionCompressor
public static uint CompressQuaternion(ref Quaternion quaternion)
{
// Store off the absolute value for each Quaternion element
- s_QuatAbsValues[0] = Mathf.Abs(quaternion[0]);
- s_QuatAbsValues[1] = Mathf.Abs(quaternion[1]);
- s_QuatAbsValues[2] = Mathf.Abs(quaternion[2]);
- s_QuatAbsValues[3] = Mathf.Abs(quaternion[3]);
+ var quatAbsValue0 = Mathf.Abs(quaternion[0]);
+ var quatAbsValue1 = Mathf.Abs(quaternion[1]);
+ var quatAbsValue2 = Mathf.Abs(quaternion[2]);
+ var quatAbsValue3 = Mathf.Abs(quaternion[3]);
// Get the largest element value of the quaternion to know what the remaining "Smallest Three" values are
- var quatMax = Mathf.Max(s_QuatAbsValues[0], s_QuatAbsValues[1], s_QuatAbsValues[2], s_QuatAbsValues[3]);
+ var quatMax = Mathf.Max(quatAbsValue0, quatAbsValue1, quatAbsValue2, quatAbsValue3);
- // Find the index of the largest element so we can skip that element while compressing and decompressing
- var indexToSkip = (ushort)(s_QuatAbsValues[0] == quatMax ? 0 : s_QuatAbsValues[1] == quatMax ? 1 : s_QuatAbsValues[2] == quatMax ? 2 : 3);
+ // Find the index of the largest element, so we can skip that element while compressing and decompressing
+ var indexToSkip = (ushort)(quatAbsValue0 == quatMax ? 0 : quatAbsValue1 == quatMax ? 1 : quatAbsValue2 == quatMax ? 2 : 3);
// Get the sign of the largest element which is all that is needed when calculating the sum of squares of a normalized quaternion.
-
var quatMaxSign = (quaternion[indexToSkip] < 0 ? k_True : k_False);
// Start with the index to skip which will be shifted to the highest two bits
var compressed = (uint)indexToSkip;
- // Step 1: Start with the first element
- var currentIndex = 0;
-
- // Step 2: If we are on the index to skip preserve the current compressed value, otherwise proceed to step 3 and 4
- // Step 3: Get the sign of the element we are processing. If it is the not the same as the largest value's sign bit then we set the bit
- // Step 4: Get the compressed and encoded value by multiplying the absolute value of the current element by k_CompressionEcodingMask and round that result up
- compressed = currentIndex != indexToSkip ? (compressed << 10) | (uint)((quaternion[currentIndex] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * s_QuatAbsValues[currentIndex]) : compressed;
- currentIndex++;
- // Repeat the last 3 steps for the remaining elements
- compressed = currentIndex != indexToSkip ? (compressed << 10) | (uint)((quaternion[currentIndex] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * s_QuatAbsValues[currentIndex]) : compressed;
- currentIndex++;
- compressed = currentIndex != indexToSkip ? (compressed << 10) | (uint)((quaternion[currentIndex] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * s_QuatAbsValues[currentIndex]) : compressed;
- currentIndex++;
- compressed = currentIndex != indexToSkip ? (compressed << 10) | (uint)((quaternion[currentIndex] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * s_QuatAbsValues[currentIndex]) : compressed;
+ // Step 1: If we are on the index to skip, preserve the current compressed value, otherwise proceed to step 2 and 3
+ // Step 2: Get the sign of the element we are processing. If it is not the same as the largest value's sign bit then we set the bit
+ // Step 3: Get the compressed and encoded value by multiplying the absolute value of the current element by k_CompressionEncodingMask and round that result up
+ compressed = 0 != indexToSkip ? (compressed << 10) | (uint)((quaternion[0] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEncodingMask * quatAbsValue0) : compressed;
+ // Repeat the 3 steps for the remaining elements
+ compressed = 1 != indexToSkip ? (compressed << 10) | (uint)((quaternion[1] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEncodingMask * quatAbsValue1) : compressed;
+ compressed = 2 != indexToSkip ? (compressed << 10) | (uint)((quaternion[2] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEncodingMask * quatAbsValue2) : compressed;
+ compressed = 3 != indexToSkip ? (compressed << 10) | (uint)((quaternion[3] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEncodingMask * quatAbsValue3) : compressed;
// Return the compress quaternion
return compressed;
@@ -111,7 +101,7 @@ public static void DecompressQuaternion(ref Quaternion quaternion, uint compress
continue;
}
// Check the negative bit and multiply that result with the decompressed and decoded value
- quaternion[i] = ((compressed & k_NegShortBit) > 0 ? -1.0f : 1.0f) * ((compressed & k_PrecisionMask) * k_DcompressionDecodingMask);
+ quaternion[i] = ((compressed & k_NegShortBit) > 0 ? -1.0f : 1.0f) * ((compressed & k_PrecisionMask) * k_DecompressionDecodingMask);
sumOfSquaredMagnitudes += quaternion[i] * quaternion[i];
compressed = compressed >> 10;
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Components/RigidbodyContactEventManager.cs b/com.unity.netcode.gameobjects/Runtime/Components/RigidbodyContactEventManager.cs
index bf54c4d964..3c94eae424 100644
--- a/com.unity.netcode.gameobjects/Runtime/Components/RigidbodyContactEventManager.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Components/RigidbodyContactEventManager.cs
@@ -2,6 +2,7 @@
using System.Collections.Generic;
using Unity.Collections;
using Unity.Jobs;
+using Unity.Netcode.Logging;
using Unity.Netcode.Runtime;
using UnityEngine;
@@ -20,7 +21,7 @@ public struct ContactEventHandlerInfo
///
public bool ProvideNonRigidBodyContactEvents;
///
- /// When set to true, the will prioritize invoking
+ /// When set to true, the will prioritize invoking
/// if it is the 2nd colliding body in the contact pair being processed. With distributed authority, setting this value to true when a is owned by the local client
/// will assure is only invoked on the authoritative side.
///
@@ -105,14 +106,16 @@ private struct JobResultStruct
private readonly Dictionary m_HandlerInfo = new Dictionary();
#endif
+ private ContextualLogger m_Log;
private void OnEnable()
{
+ m_Log = new ContextualLogger(this);
m_ResultsArray = new NativeArray(16, Allocator.Persistent);
Physics.ContactEvent += Physics_ContactEvent;
- if (Instance != null)
+ if (Instance != null && Instance != this)
{
- NetworkLog.LogError($"[Invalid][Multiple Instances] Found more than one instance of {nameof(RigidbodyContactEventManager)}: {name} and {Instance.name}");
- NetworkLog.LogError($"[Disable][Additional Instance] Disabling {name} instance!");
+ m_Log.Error(new Context(LogLevel.Error, $"Found more than one instance of {nameof(RigidbodyContactEventManager)}").AddTag("Invalid").AddTag("Multiple Instances").AddInfo("Instance 1", Instance.name).AddInfo("Instance 2", name));
+ m_Log.Error(new Context(LogLevel.Error, $"Disabling instance: ").AddTag("Disable").AddTag("Additional Instance").AddInfo("Instance", name));
gameObject.SetActive(false);
return;
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Configuration/CommandLineOptions.cs b/com.unity.netcode.gameobjects/Runtime/Configuration/CommandLineOptions.cs
index c6f9b4a222..67878b125a 100644
--- a/com.unity.netcode.gameobjects/Runtime/Configuration/CommandLineOptions.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Configuration/CommandLineOptions.cs
@@ -1,6 +1,5 @@
using System;
using System.Collections.Generic;
-using UnityEngine;
namespace Unity.Netcode
{
@@ -13,6 +12,7 @@ public class CommandLineOptions
///
/// Command-line options singleton
///
+ [Obsolete("Not used anymore replaced by TryGetArg")]
public static CommandLineOptions Instance
{
get
@@ -30,34 +30,41 @@ private set
}
private static CommandLineOptions s_Instance;
- [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
- private static void RuntimeInitializeOnLoad() => Instance = new CommandLineOptions();
-
// Contains the current application instance domain's command line arguments
- internal static List CommandLineArguments = new List();
-
- // Invoked upon application start, after scene load
- [RuntimeInitializeOnLoadMethod]
- private static void ParseCommandLineArguments()
- {
- // Get all the command line arguments to be parsed later and/or modified
- // prior to being parsed (for testing purposes).
- CommandLineArguments = new List(Environment.GetCommandLineArgs());
- }
+ private static readonly List k_CommandLineArguments = new List(Environment.GetCommandLineArgs());
///
- /// Returns the value of an argument or null if there the argument is not present
+ /// Returns the value of an argument or null if the argument is not present
///
/// The name of the argument
/// Value of the command line argument passed in.
+ [Obsolete("Not used anymore replaced by TryGetArg")]
public string GetArg(string arg)
{
- var argIndex = CommandLineArguments.IndexOf(arg);
- if (argIndex >= 0 && argIndex < CommandLineArguments.Count - 1)
+ var argIndex = k_CommandLineArguments.IndexOf(arg);
+ if (argIndex >= 0 && argIndex < k_CommandLineArguments.Count - 1)
{
- return CommandLineArguments[argIndex + 1];
+ return k_CommandLineArguments[argIndex + 1];
}
return null;
}
+
+ ///
+ /// Returns true if the argument was found.
+ ///
+ /// The name of the argument to look up.
+ /// The argument's value, or if not found.
+ /// true if the argument was found; otherwise false.
+ public static bool TryGetArg(string arg, out string argValue)
+ {
+ var argIndex = k_CommandLineArguments.IndexOf(arg);
+ if (argIndex >= 0 && argIndex < k_CommandLineArguments.Count - 1)
+ {
+ argValue = k_CommandLineArguments[argIndex + 1];
+ return true;
+ }
+ argValue = null;
+ return false;
+ }
}
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkConstants.cs b/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkConstants.cs
index b9eed28790..bc862c8fe2 100644
--- a/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkConstants.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkConstants.cs
@@ -5,6 +5,6 @@ namespace Unity.Netcode
///
internal static class NetworkConstants
{
- internal const string PROTOCOL_VERSION = "15.0.0";
+ internal const string PROTOCOL_VERSION = "15.1.0";
}
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefab.cs b/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefab.cs
index c6f30d2835..b1c071e705 100644
--- a/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefab.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefab.cs
@@ -166,6 +166,22 @@ public bool Validate(int index = -1)
return false;
}
+ if (networkObject.InScenePlaced)
+ {
+ if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
+ {
+ NetworkLog.LogWarning($"{NetworkPrefabHandler.PrefabDebugHelper(this)} InScenePlaced {nameof(NetworkObject)} is being registered as a Prefab. This can cause issues!");
+ }
+ }
+
+ if (networkObject.IsSpawned)
+ {
+ if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
+ {
+ NetworkLog.LogWarning($"{NetworkPrefabHandler.PrefabDebugHelper(this)} Currently spawned {nameof(NetworkObject)} is being registered as a Prefab. This can cause issues!");
+ }
+ }
+
return true;
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefabs.cs b/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefabs.cs
index 45d93ad9d7..303055174f 100644
--- a/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefabs.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefabs.cs
@@ -47,22 +47,110 @@ public class NetworkPrefabs
[NonSerialized]
private List m_Prefabs = new List();
+ ///
+ /// Returns the last registered prefab.
+ ///
+ internal NetworkPrefab GetLastRegisteredPrefab()
+ {
+ if (m_Prefabs.Count == 0)
+ {
+ return null;
+ }
+ return m_Prefabs[m_Prefabs.Count - 1];
+ }
+
+ ///
+ /// Applies a network prefab at a specific index
+ ///
+ /// index to apply
+ /// network prefab to be applied
+ ///
+ internal bool AssignPrefabAtIndex(int index, NetworkPrefab networkPrefab)
+ {
+ if (index >= m_Prefabs.Count)
+ {
+ NetworkManager.Singleton.Log.Error(new Logging.Context(LogLevel.Normal, $"[{nameof(NetworkPrefabs)}][{nameof(AssignPrefabAtIndex)}] Cannot apply prefab to index {index} when the {nameof(m_Prefabs)} count is only {m_Prefabs.Count}!"));
+ return false;
+ }
+ m_Prefabs[index] = networkPrefab;
+ return true;
+ }
+
+ [NonSerialized]
+ private Dictionary m_PrefabHashIds = new Dictionary();
+
[NonSerialized]
private List m_RuntimeAddedPrefabs = new List();
- private void AddTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab)
+ private bool InternalAddPrefab(NetworkPrefab networkPrefab)
{
if (AddPrefabRegistration(networkPrefab))
{
// Don't add this to m_RuntimeAddedPrefabs
// This prefab is now in the PrefabList, so if we shutdown and initialize again, we'll pick it up from there.
m_Prefabs.Add(networkPrefab);
+
+ // We are not getting all potential overrides but just determining if the prefab has been registered.
+ if (!m_PrefabHashIds.ContainsKey(networkPrefab.SourcePrefabGlobalObjectIdHash))
+ {
+ m_PrefabHashIds.Add(networkPrefab.SourcePrefabGlobalObjectIdHash, networkPrefab);
+ }
+ if (!m_PrefabHashIds.ContainsKey(networkPrefab.TargetPrefabGlobalObjectIdHash))
+ {
+ m_PrefabHashIds.Add(networkPrefab.TargetPrefabGlobalObjectIdHash, networkPrefab);
+ }
+ return true;
}
+ return false;
}
- private void RemoveTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab)
+ private void InternalRemovePrefab(NetworkPrefab networkPrefab)
{
m_Prefabs.Remove(networkPrefab);
+ m_PrefabHashIds.Remove(networkPrefab.SourcePrefabGlobalObjectIdHash);
+ }
+
+ internal bool IsBasedOnRegisteredPrefab(NetworkObject networkObject)
+ {
+
+
+ return m_PrefabHashIds.ContainsKey(networkObject.GlobalObjectIdHash);
+ }
+
+ internal bool IsActualPrefabAsset(NetworkObject networkObject)
+ {
+ var isActualPrefabAsset = false;
+ if (m_PrefabHashIds.TryGetValue(networkObject.GlobalObjectIdHash, out NetworkPrefab networkPrefab))
+ {
+ switch (networkPrefab.Override)
+ {
+ case NetworkPrefabOverride.Prefab:
+ case NetworkPrefabOverride.None:
+ {
+ isActualPrefabAsset = networkPrefab.Prefab != null && networkObject.gameObject == networkPrefab.Prefab;
+ break;
+ }
+ case NetworkPrefabOverride.Hash:
+ {
+ isActualPrefabAsset = networkPrefab.SourceHashToOverride == networkObject.GlobalObjectIdHash;
+ break;
+ }
+ }
+ }
+ return isActualPrefabAsset;
+ }
+
+ private void AddTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab)
+ {
+ // Don't add this to m_RuntimeAddedPrefabs
+ // This prefab is now in the PrefabList, so if we shutdown and initialize again, we'll pick it up from there.
+ InternalAddPrefab(networkPrefab);
+ // Log warning if this returns false?
+ }
+
+ private void RemoveTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab)
+ {
+ InternalRemovePrefab(networkPrefab);
}
///
@@ -93,6 +181,7 @@ internal void Shutdown()
/// When true, logs warnings about invalid prefabs that are removed during initialization
public void Initialize(bool warnInvalid = true)
{
+ m_PrefabHashIds.Clear();
m_Prefabs.Clear();
NetworkPrefabsLists.RemoveAll(x => x == null);
foreach (var list in NetworkPrefabsLists)
@@ -113,7 +202,7 @@ public void Initialize(bool warnInvalid = true)
prefabs.AddRange(list.PrefabList);
}
}
-
+ m_PrefabHashIds = new Dictionary();
m_Prefabs = new List();
List removeList = null;
@@ -124,11 +213,7 @@ public void Initialize(bool warnInvalid = true)
foreach (var networkPrefab in prefabs)
{
- if (AddPrefabRegistration(networkPrefab))
- {
- m_Prefabs.Add(networkPrefab);
- }
- else
+ if (!InternalAddPrefab(networkPrefab))
{
removeList?.Add(networkPrefab);
}
@@ -136,11 +221,7 @@ public void Initialize(bool warnInvalid = true)
foreach (var networkPrefab in m_RuntimeAddedPrefabs)
{
- if (AddPrefabRegistration(networkPrefab))
- {
- m_Prefabs.Add(networkPrefab);
- }
- else
+ if (!InternalAddPrefab(networkPrefab))
{
removeList?.Add(networkPrefab);
}
@@ -171,14 +252,12 @@ public void Initialize(bool warnInvalid = true)
///
public bool Add(NetworkPrefab networkPrefab)
{
- if (AddPrefabRegistration(networkPrefab))
+ var added = InternalAddPrefab(networkPrefab);
+ if (added)
{
- m_Prefabs.Add(networkPrefab);
m_RuntimeAddedPrefabs.Add(networkPrefab);
- return true;
}
-
- return false;
+ return added;
}
///
@@ -197,8 +276,7 @@ public void Remove(NetworkPrefab prefab)
{
throw new ArgumentNullException(nameof(prefab));
}
-
- m_Prefabs.Remove(prefab);
+ InternalRemovePrefab(prefab);
m_RuntimeAddedPrefabs.Remove(prefab);
OverrideToNetworkPrefab.Remove(prefab.TargetPrefabGlobalObjectIdHash);
NetworkPrefabOverrideLinks.Remove(prefab.SourcePrefabGlobalObjectIdHash);
@@ -294,14 +372,12 @@ private bool AddPrefabRegistration(NetworkPrefab networkPrefab)
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();
-
+ var nameOrHashOverride = networkPrefab.Override == NetworkPrefabOverride.Hash ? $"Hash: {networkPrefab.SourcePrefabGlobalObjectIdHash}" : networkPrefab.Prefab?.name;
// 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}!");
+ Debug.LogError($"{nameof(NetworkPrefab)} ({nameOrHashOverride}) has a duplicate {nameof(NetworkObject.GlobalObjectIdHash)} source entry value of: {source}!");
return false;
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs b/com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs
index aaeb67f4db..3ff131131f 100644
--- a/com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs
@@ -96,7 +96,7 @@ public struct ConnectionEventData
///
public sealed class NetworkConnectionManager
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
private static ProfilerMarker s_TransportPollMarker = new ProfilerMarker($"{nameof(NetworkManager)}.TransportPoll");
private static ProfilerMarker s_TransportConnect = new ProfilerMarker($"{nameof(NetworkManager)}.TransportConnect");
private static ProfilerMarker s_HandleIncomingData = new ProfilerMarker($"{nameof(NetworkManager)}.{nameof(NetworkMessageManager.HandleIncomingData)}");
@@ -438,7 +438,7 @@ private ulong GetServerTransportId()
internal void PollAndHandleNetworkEvents()
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
s_TransportPollMarker.Begin();
#endif
NetworkEvent networkEvent;
@@ -453,7 +453,7 @@ internal void PollAndHandleNetworkEvents()
// Only do another iteration if: there are no more messages AND (there is no limit to max events or we have processed less than the maximum)
} while (NetworkManager.IsListening && networkEvent != NetworkEvent.Nothing);
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
s_TransportPollMarker.End();
#endif
}
@@ -501,7 +501,7 @@ internal void HandleNetworkEvent(NetworkEvent networkEvent, ulong transportClien
///
internal void ConnectEventHandler(ulong transportId)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
s_TransportConnect.Begin();
#endif
// Assumptions:
@@ -522,6 +522,9 @@ internal void ConnectEventHandler(ulong transportId)
{
NetworkLog.LogError($"[TransportApproval][Server] TransportId {transportId} is already connected to this server!");
}
+#if DEBUG
+ s_TransportConnect.End();
+#endif
return;
}
@@ -536,6 +539,9 @@ internal void ConnectEventHandler(ulong transportId)
{
NetworkLog.LogError("[TransportApproval][Client] Client received a transport connection event after already connecting!");
}
+#if DEBUG
+ s_TransportConnect.End();
+#endif
return;
}
@@ -571,7 +577,7 @@ internal void ConnectEventHandler(ulong transportId)
StartClientApprovalCoroutine(clientId);
}
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
s_TransportConnect.End();
#endif
}
@@ -581,7 +587,7 @@ internal void ConnectEventHandler(ulong transportId)
///
internal void DataEventHandler(ulong transportClientId, ref ArraySegment payload, float receiveTime)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
s_HandleIncomingData.Begin();
#endif
var (clientId, isConnectedClient) = TransportIdToClientId(transportClientId);
@@ -590,7 +596,7 @@ internal void DataEventHandler(ulong transportClientId, ref ArraySegment p
MessageManager.HandleIncomingData(clientId, payload, receiveTime);
}
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
s_HandleIncomingData.End();
#endif
}
@@ -633,7 +639,7 @@ internal void DisconnectEventHandler(ulong transportClientId)
return;
}
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
s_TransportDisconnect.Begin();
#endif
@@ -692,7 +698,7 @@ internal void DisconnectEventHandler(ulong transportClientId)
NetworkManager.Shutdown(true);
}
}
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
s_TransportDisconnect.End();
#endif
}
@@ -961,8 +967,7 @@ internal void ProcessClientsToDisconnect()
{
return (true, playerPrefabHash.Value);
}
- else
- if (NetworkManager.NetworkConfig.PlayerPrefab != null)
+ else if (NetworkManager.NetworkConfig.PlayerPrefab != null)
{
var networkObject = NetworkManager.NetworkConfig.PlayerPrefab.GetComponent();
if (networkObject != null)
@@ -1184,7 +1189,11 @@ internal void CreateAndSpawnPlayer(ulong ownerId)
return;
}
- networkObject.IsSceneObject = false;
+#pragma warning disable CS0618 // Type or member is obsolete
+ // Obsolete with warning means we need the underlying behaviour to keep existing
+ // TODO: remove in the 3.x branch
+ networkObject.SetSceneObjectStatus(false);
+#pragma warning restore CS0618 // Type or member is obsolete
networkObject.NetworkManagerOwner = NetworkManager;
networkObject.SpawnAsPlayerObject(ownerId, networkObject.DestroyWithScene);
}
@@ -1208,7 +1217,7 @@ internal void ApprovedPlayerSpawn(ulong clientId, uint playerPrefabHash)
var message = new CreateObjectMessage
{
- ObjectInfo = ConnectedClients[clientId].PlayerObject.Serialize(clientPair.Key),
+ ObjectInfo = ConnectedClients[clientId].PlayerObject.SerializeSpawnedObject(clientPair.Key),
IncludesSerializedObject = true,
};
diff --git a/com.unity.netcode.gameobjects/Runtime/Core/ComponentFactory.cs b/com.unity.netcode.gameobjects/Runtime/Core/ComponentFactory.cs
index 52945c4e46..6733429ee2 100644
--- a/com.unity.netcode.gameobjects/Runtime/Core/ComponentFactory.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Core/ComponentFactory.cs
@@ -14,6 +14,10 @@ internal static class ComponentFactory
internal delegate object CreateObjectDelegate(NetworkManager networkManager);
private static Dictionary s_Delegates = new Dictionary();
+#if UNITY_EDITOR
+ [UnityEngine.RuntimeInitializeOnLoadMethod(UnityEngine.RuntimeInitializeLoadType.SubsystemRegistration)]
+ private static void ResetStaticsOnLoad() => s_Delegates = new Dictionary();
+#endif
///
/// Instantiates an instance of a given interface
diff --git a/com.unity.netcode.gameobjects/Runtime/Core/FindObjects.cs b/com.unity.netcode.gameobjects/Runtime/Core/FindObjects.cs
index a283cabe52..109d40f4d3 100644
--- a/com.unity.netcode.gameobjects/Runtime/Core/FindObjects.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Core/FindObjects.cs
@@ -1,7 +1,8 @@
-#if NGO_FINDOBJECTS_NOSORTING
using System;
-#endif
+using System.Collections;
+using System.Collections.Generic;
using System.Runtime.CompilerServices;
+using UnityEngine.SceneManagement;
using Object = UnityEngine.Object;
namespace Unity.Netcode
@@ -11,14 +12,14 @@ namespace Unity.Netcode
///
///
/// It is intentional that we do not include the UnityEngine namespace in order to avoid
- /// over-complicatd define wrapping between versions that do or don't support FindObjectsSortMode.
+ /// over-complicated define wrapping between versions that do or don't support FindObjectsSortMode.
///
internal static class FindObjects
{
///
/// Replaces to have one place where these changes are applied.
///
- ///
+ /// The type of object to find. Must be a reference type derived from
/// When true, inactive objects will be included.
/// When true, the array returned will be sorted by identifier.
/// Results as an of type T
@@ -39,5 +40,90 @@ public static T[] ByType(bool includeInactive = false, bool orderByIdentifier
#endif
return results;
}
+
+ ///
+ /// Returns an enumerator that enumerates over all the components of a given type in a scene.
+ ///
+ /// The scene to use for searching
+ /// When true, inactive objects will be included.
+ /// Type of to get from the scene
+ /// a generator that yields successive NetworkObjects in the current scene
+ public static IEnumerable FromSceneByType(Scene scene, bool includeInactive) where T : UnityEngine.Component
+ {
+ return new ObjectsInSceneEnumerator(scene, includeInactive);
+ }
+
+ ///
+ /// An Enumerator that enumerates over each component of type in the given scene.
+ ///
+ /// Type of to get from the scene
+ private struct ObjectsInSceneEnumerator : IEnumerable, IEnumerator where T : UnityEngine.Component
+ {
+ private readonly UnityEngine.GameObject[] m_RootObjects;
+ private int m_RootIndex;
+ private T[] m_CurrentChildObjects;
+ private int m_CurrentChildIndex;
+
+ private readonly bool m_IncludeInactive;
+
+ internal ObjectsInSceneEnumerator(Scene scene, bool includeInactive)
+ {
+ m_IncludeInactive = includeInactive;
+ // If the scene is invalid, use an empty array.
+ m_RootObjects = scene.IsValid() ? scene.GetRootGameObjects() : new UnityEngine.GameObject[0];
+ m_RootIndex = 0;
+ m_CurrentChildObjects = null;
+ m_CurrentChildIndex = 0;
+ Current = null;
+ }
+
+ public void Dispose() { }
+
+ public bool MoveNext()
+ {
+ while (m_CurrentChildObjects == null && m_RootIndex < m_RootObjects.Length)
+ {
+ m_CurrentChildObjects = m_RootObjects[m_RootIndex].GetComponentsInChildren(m_IncludeInactive);
+ m_RootIndex++;
+
+ if (m_CurrentChildObjects.Length == 0)
+ {
+ m_CurrentChildObjects = null;
+ }
+ }
+
+ if (m_CurrentChildObjects != null && m_CurrentChildIndex < m_CurrentChildObjects.Length)
+ {
+ Current = m_CurrentChildObjects[m_CurrentChildIndex];
+ m_CurrentChildIndex++;
+
+ if (m_CurrentChildIndex >= m_CurrentChildObjects.Length)
+ {
+ m_CurrentChildIndex = 0;
+ m_CurrentChildObjects = null;
+ }
+ return true;
+ }
+
+ Current = null;
+ return false;
+ }
+
+ public void Reset()
+ {
+ m_RootIndex = 0;
+ m_CurrentChildObjects = null;
+ m_CurrentChildIndex = 0;
+ Current = null;
+ }
+
+ object IEnumerator.Current => Current;
+
+ public T Current { get; private set; }
+
+ public IEnumerator GetEnumerator() => this;
+
+ IEnumerator IEnumerable.GetEnumerator() => this;
+ }
}
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviour.cs b/com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviour.cs
index 59f9e637b6..16b6d3be62 100644
--- a/com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviour.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviour.cs
@@ -43,7 +43,7 @@ public abstract class NetworkBehaviour : MonoBehaviour
internal static readonly Dictionary> __rpc_func_table = new Dictionary>();
internal static readonly Dictionary> __rpc_permission_table = new Dictionary>();
-#if MULTIPLAYER_TOOLS && (DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
+#if MULTIPLAYER_TOOLS && (DEBUG || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
// RuntimeAccessModifiersILPP will make this `public`
internal static readonly Dictionary> __rpc_name_table = new Dictionary>();
#endif
@@ -145,7 +145,7 @@ internal void __endSendServerRpc(ref FastBufferWriter bufferWriter, uint rpcMeth
bufferWriter.Dispose();
-#if MULTIPLAYER_TOOLS && (DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
+#if MULTIPLAYER_TOOLS && (DEBUG || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
TrackRpcMetricsSend(ref serverRpcMessage, rpcMethodId, rpcWriteSize);
#endif
}
@@ -269,7 +269,7 @@ internal void __endSendClientRpc(ref FastBufferWriter bufferWriter, uint rpcMeth
}
bufferWriter.Dispose();
-#if MULTIPLAYER_TOOLS && (DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
+#if MULTIPLAYER_TOOLS && (DEBUG || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
if (!ValidateRpcMessageMetrics(GetType()))
{
return;
@@ -1002,12 +1002,12 @@ internal void __registerRpc(uint hash, RpcReceiveHandler handler, string rpcMeth
var rpcType = GetType();
__rpc_func_table[rpcType][hash] = handler;
__rpc_permission_table[rpcType][hash] = permission;
-#if MULTIPLAYER_TOOLS && (DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
+#if MULTIPLAYER_TOOLS && (DEBUG || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
__rpc_name_table[rpcType][hash] = rpcMethodName;
#endif
}
-#if MULTIPLAYER_TOOLS && (DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
+#if MULTIPLAYER_TOOLS && (DEBUG || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private bool ValidateRpcMessageMetrics(Type type)
{
@@ -1125,7 +1125,7 @@ internal void InitializeVariables()
{
__rpc_func_table[GetType()] = new Dictionary();
__rpc_permission_table[GetType()] = new Dictionary();
-#if MULTIPLAYER_TOOLS && (DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
+#if MULTIPLAYER_TOOLS && (DEBUG || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
__rpc_name_table[GetType()] = new Dictionary();
#endif
__initializeRpcs();
@@ -1299,8 +1299,6 @@ internal void NetworkVariableUpdate(ulong targetClientId, bool forceSend = false
}
}
- internal static bool LogSentVariableUpdateMessage;
-
private bool CouldHaveDirtyNetworkVariables()
{
// TODO: There should be a better way by reading one dirty variable vs. 'n'
diff --git a/com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviourUpdater.cs b/com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviourUpdater.cs
index 4f12bca033..871c8afb7d 100644
--- a/com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviourUpdater.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviourUpdater.cs
@@ -27,7 +27,7 @@ public class NetworkBehaviourUpdater
///
private HashSet m_PendingDirtyNetworkObjects = new HashSet();
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
private ProfilerMarker m_NetworkBehaviourUpdate = new ProfilerMarker($"{nameof(NetworkBehaviour)}.{nameof(NetworkBehaviourUpdate)}");
#endif
@@ -190,7 +190,7 @@ internal void ProcessDirtyObject(NetworkObject networkObject, bool forceSend)
/// Refer to the definition.
internal void NetworkBehaviourUpdate(bool forceSend = false)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
m_NetworkBehaviourUpdate.Begin();
#endif
try
@@ -214,7 +214,7 @@ internal void NetworkBehaviourUpdate(bool forceSend = false)
}
finally
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
m_NetworkBehaviourUpdate.End();
#endif
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs b/com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs
index b9a2c15789..453f10b88f 100644
--- a/com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs
@@ -21,6 +21,20 @@ namespace Unity.Netcode
[HelpURL(HelpUrls.NetworkManager)]
public class NetworkManager : MonoBehaviour, INetworkUpdateSystem
{
+#if UNITY_EDITOR
+ [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+ private static void ResetStaticsOnLoad()
+ {
+ Singleton = null;
+ OnInstantiated = null;
+ OnDestroying = null;
+ OnSingletonReady = null;
+ OnNetworkManagerReset = null;
+ IsDistributedAuthority = false;
+ s_SerializedType = new List();
+ DisableNotOptimizedSerializedType = false;
+ }
+#endif
///
/// Subscribe to this static event to get notifications when a instance has been instantiated.
///
@@ -31,7 +45,6 @@ public class NetworkManager : MonoBehaviour, INetworkUpdateSystem
///
public static event Action OnDestroying;
-
#if UNITY_EDITOR
// Inspector view expand/collapse settings for this derived child class
[HideInInspector]
@@ -44,17 +57,20 @@ public class NetworkManager : MonoBehaviour, INetworkUpdateSystem
#pragma warning disable IDE1006 // disable naming rule violation check
// RuntimeAccessModifiersILPP will make this `public`
+ [Obsolete("This field is no longer used and will be removed in a future version.")]
internal delegate void RpcReceiveHandler(NetworkBehaviour behaviour, FastBufferReader reader, __RpcParams parameters);
// RuntimeAccessModifiersILPP will make this `public`
+ [Obsolete("This field is no longer used and will be removed in a future version.")]
internal static readonly Dictionary __rpc_func_table = new Dictionary();
// RuntimeAccessModifiersILPP will make this `public` (legacy table should be removed in v3.x.x)
+ [Obsolete("This field is no longer used and will be removed in a future version.")]
internal static readonly Dictionary __rpc_name_table = new Dictionary();
#pragma warning restore IDE1006 // restore naming rule violation check
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
private static List s_SerializedType = new List();
// This is used to control the serialized type not optimized messaging for integration test purposes
internal static bool DisableNotOptimizedSerializedType;
@@ -1013,7 +1029,7 @@ internal bool NetworkManagerCheckForParent(bool ignoreNetworkManagerCache = fals
var isParented = transform.root != transform;
if (isParented)
{
- throw new Exception(GenerateNestedNetworkManagerMessage(transform));
+ Log.Error(new Context(LogLevel.Error, GenerateNestedNetworkManagerMessage(transform)));
}
#endif
return isParented;
@@ -1160,7 +1176,7 @@ public int MaximumFragmentedMessageSize
internal void Initialize(bool server)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (!DisableNotOptimizedSerializedType)
{
s_SerializedType.Clear();
@@ -1223,7 +1239,7 @@ internal void Initialize(bool server)
MessageManager.Hook(new NetworkManagerHooks(this));
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (NetworkConfig.NetworkProfilingMetrics)
{
MessageManager.Hook(new ProfilingHooks());
@@ -1641,7 +1657,7 @@ internal void ShutdownInternal()
// place (i.e. sending any last state updates or the like).
SpawnManager?.DespawnAndDestroyNetworkObjects();
- SpawnManager?.ServerResetShudownStateForSceneObjects();
+ SpawnManager?.ServerResetShutdownStateForSceneObjects();
////
RpcTarget?.Dispose();
@@ -1797,6 +1813,10 @@ internal abstract class NetcodeAnalytics
internal static ResetNetworkManagerDelegate OnNetworkManagerReset;
+
+ ///
+ /// This is called by the Unity Editor reset button. See which is handled in "NetworkManagerHelper.cs".
+ ///
private void Reset()
{
OnNetworkManagerReset?.Invoke(this);
diff --git a/com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs b/com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs
index d2f5aa5869..4c42f83a30 100644
--- a/com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs
@@ -1,17 +1,15 @@
using System;
using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using Unity.Netcode.Components;
+using Unity.Netcode.Logging;
using Unity.Netcode.Runtime;
#if UNITY_EDITOR
using UnityEditor;
-#if UNITY_2021_2_OR_NEWER
using UnityEditor.SceneManagement;
-#else
-using UnityEditor.Experimental.SceneManagement;
-#endif
#endif
using UnityEngine;
using UnityEngine.SceneManagement;
@@ -105,6 +103,9 @@ public uint PrefabIdHash
///
public NetworkObject CurrentParent { get; private set; }
+ private int m_SpawnCount;
+ internal bool HasBeenSpawned => m_SpawnCount > 0;
+
#if UNITY_EDITOR
private const string k_GlobalIdTemplate = "GlobalObjectId_V1-{0}-{1}-{2}-{3}";
@@ -128,9 +129,6 @@ public uint PrefabIdHash
// The InContext or InIsolation edit mode network prefab scene instance of the prefab asset (s_PrefabAsset).
private static NetworkObject s_PrefabInstance;
- private static bool s_DebugPrefabIdGeneration;
-
-
[ContextMenu("Refresh In-Scene Prefab Instances")]
internal void RefreshAllPrefabInstances()
{
@@ -291,7 +289,7 @@ internal void OnValidate()
if (GlobalObjectIdHash != oldValue)
{
// Check if this is an in-scnee placed NetworkObject (Special Case for In-Scene Placed).
- if (IsSceneObject.HasValue && IsSceneObject.Value)
+ if (InScenePlaced)
{
// Sanity check to make sure this is a scene placed object.
if (globalId.identifierType != k_SceneObjectType)
@@ -327,7 +325,7 @@ internal void OnValidate()
///
private void CheckForInScenePlaced()
{
- if (gameObject.scene.IsValid() && gameObject.scene.isLoaded && gameObject.scene.buildIndex >= 0)
+ if (gameObject.scene.IsValid() && gameObject.scene.buildIndex >= 0)
{
if (PrefabUtility.IsPartOfAnyPrefab(this))
{
@@ -340,14 +338,43 @@ private void CheckForInScenePlaced()
EditorUtility.SetDirty(this);
}
}
- IsSceneObject = true;
+
+#pragma warning disable CS0618 // Type or member is obsolete
+ // Obsolete with warning means we need the underlying behaviour to keep existing
+ // TODO-3.x: remove in the 3.x branch
+ SetSceneObjectStatus(true);
+#pragma warning restore CS0618 // Type or member is obsolete
+
+ // We go ahead and set this for "typical in-scene placed" usage patterns so this is serialized
+ InScenePlaced = true;
// Default scene migration synchronization to false for in-scene placed NetworkObjects
SceneMigrationSynchronization = false;
+
+ // Set our disabled in-scene placed flag for spawning initially disabled in-scene placed objects.
+ m_InScenePlacedDisabledByDefault = !gameObject.activeInHierarchy;
}
}
#endif // UNITY_EDITOR
+ ///
+ /// This is intentionally private since this is a sealed class.
+ ///
+ private void Awake()
+ {
+ SetCachedParent(transform.parent);
+ SceneOrigin = gameObject.scene;
+ }
+
+ ///
+ /// Used to provide support for initially disabled in-scene placed objects.
+ /// This is only ever set on in-scene placed objects that are already disabled
+ /// in the scene asset itself.
+ ///
+ [HideInInspector]
+ [SerializeField]
+ private bool m_InScenePlacedDisabledByDefault;
+
///
/// Gets the NetworkManager that owns this NetworkObject instance
///
@@ -411,7 +438,7 @@ public void DeferDespawn(int tickOffset, bool destroy = true)
return;
}
- if (!HasAuthority)
+ if (!m_HasAuthority)
{
if (NetworkManagerOwner.LogLevel <= LogLevel.Error)
{
@@ -628,7 +655,7 @@ public bool SetOwnershipLock(bool lockOwnership = true)
}
// If we don't have authority exit early
- if (!HasAuthority)
+ if (!m_HasAuthority)
{
if (NetworkManager.LogLevel <= LogLevel.Error)
{
@@ -904,7 +931,7 @@ internal void OwnershipRequest(ulong clientRequestingOwnership)
// This action is always authorized as long as the client still has authority.
// We need to pass in that this is a request approval ownership change.
- NetworkManagerOwner.SpawnManager.ChangeOwnership(this, clientRequestingOwnership, HasAuthority, true);
+ NetworkManagerOwner.SpawnManager.ChangeOwnership(this, clientRequestingOwnership, m_HasAuthority, true);
}
else
{
@@ -1150,14 +1177,9 @@ public bool HasOwnershipStatus(OwnershipStatus status)
///
/// When in client-server mode, authority should is not considered the same as ownership.
///
- public bool HasAuthority => InternalHasAuthority();
+ public bool HasAuthority => IsSpawned ? m_HasAuthority : !NetworkManager.DistributedAuthorityMode && NetworkManager.IsServer;
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- private bool InternalHasAuthority()
- {
- var networkManager = NetworkManager;
- return networkManager.DistributedAuthorityMode ? OwnerClientId == networkManager.LocalClientId : networkManager.IsServer;
- }
+ private bool m_HasAuthority;
///
/// The NetworkManager that owns this NetworkObject.
@@ -1225,15 +1247,51 @@ private bool InternalHasAuthority()
public bool IsSpawned { get; internal set; }
///
- /// Gets if the object is a SceneObject, null if it's not yet spawned but is a scene object.
+ /// Gets if the object is a SceneObject.
///
+ ///
+ /// This method is marked for deprecation.
+ /// Use instead.
+ ///
+ [Obsolete("Use InScenePlaced instead")]
public bool? IsSceneObject { get; internal set; }
- //DANGOEXP TODO: Determine if we want to keep this
+
+ ///
+ /// The serialized value.
+ ///
+ [field: HideInInspector]
+ [field: SerializeField]
+ private bool m_InScenePlaced;
+
+ ///
+ /// True if this object is placed in a scene; false otherwise.
+ ///
+ public bool InScenePlaced
+ {
+ get
+ {
+ return m_InScenePlaced;
+ }
+ internal set
+ {
+ m_InScenePlaced = value;
+ }
+ }
+
+ ///
+ /// This provides a means to determine if the post processing had applied
+ /// the in-scene placed status or if it was already serialized. This is used
+ /// when determining if the thing being spawned is a valid thing to spawn.
+ ///
+ internal bool InScenePlacedPostProcessorMarkedDuringRuntime;
+
///
/// Sets whether this NetworkObject was instantiated as part of a scene
///
+ /// Only use this when using custom scene loading
/// When true, marks this as a scene-instantiated object; when false, marks it as runtime-instantiated
+ [Obsolete("SetSceneObjectStatus is now calculated during the build.")]
public void SetSceneObjectStatus(bool isSceneObject = false)
{
IsSceneObject = isSceneObject;
@@ -1434,19 +1492,20 @@ public bool IsNetworkVisibleTo(ulong clientId)
///
internal Scene SceneOrigin
{
- get
- {
- return m_SceneOrigin;
- }
+ get => m_SceneOrigin;
set
{
+ if (SceneOriginHandle.IsEmpty() && value.IsValid() && value.isLoaded)
+ {
+ SceneOriginHandle = value.handle;
+ }
+
// The scene origin should only be set once.
// Once set, it should never change.
- if (SceneOriginHandle.IsEmpty() && value.IsValid() && value.isLoaded)
+ if (!m_SceneOrigin.IsValid())
{
m_SceneOrigin = value;
- SceneOriginHandle = value.handle;
}
}
}
@@ -1457,13 +1516,8 @@ internal Scene SceneOrigin
///
internal NetworkSceneHandle GetSceneOriginHandle()
{
- if (SceneOriginHandle.IsEmpty() && IsSpawned && IsSceneObject != false)
- {
- if (NetworkManager.LogLevel <= LogLevel.Error)
- {
- NetworkLog.LogErrorServer($"{nameof(GetSceneOriginHandle)} called when {nameof(SceneOriginHandle)} is still zero but the {nameof(NetworkObject)} is already spawned!");
- }
- }
+ NetworkLog.InternalAssert(!(IsSpawned && InScenePlaced && SceneOriginHandle.IsEmpty()), $"Spawned in scene placed NetworkObject {name} should always have a valid SceneOriginHandle");
+
return !SceneOriginHandle.IsEmpty() ? SceneOriginHandle : gameObject.scene.handle;
}
@@ -1492,7 +1546,7 @@ public void NetworkShow(ulong clientId)
return;
}
- if (!HasAuthority)
+ if (!m_HasAuthority)
{
if (NetworkManagerOwner.DistributedAuthorityMode)
{
@@ -1587,7 +1641,7 @@ public void NetworkHide(ulong clientId)
return;
}
- if (!HasAuthority)
+ if (!m_HasAuthority)
{
if (NetworkManagerOwner.DistributedAuthorityMode)
{
@@ -1622,7 +1676,7 @@ public void NetworkHide(ulong clientId)
var message = new DestroyObjectMessage
{
NetworkObjectId = NetworkObjectId,
- DestroyGameObject = !IsSceneObject.Value,
+ DestroyGameObject = !InScenePlaced,
IsDistributedAuthority = NetworkManagerOwner.DistributedAuthorityMode,
IsTargetedDestroy = NetworkManagerOwner.DistributedAuthorityMode,
TargetClientId = clientId, // Just always populate this value whether we write it or not
@@ -1727,6 +1781,8 @@ internal void SetIsDestroying()
private void OnDestroy()
{
+ SceneManager.activeSceneChanged -= CurrentlyActiveSceneChanged;
+
// Apply the is destroying flag
SetIsDestroying();
@@ -1744,13 +1800,13 @@ private void OnDestroy()
{
// An authorized destroy is when done by the authority instance or done due to a scene event and the NetworkObject
// was marked as destroy pending scene event (which means the destroy with scene property was set).
- var isAuthorityDestroy = HasAuthority || NetworkManager.DAHost || DestroyPendingSceneEvent;
+ var isAuthorityDestroy = m_HasAuthority || NetworkManager.DAHost || DestroyPendingSceneEvent;
// If the NetworkObject's GameObject is still valid and the scene is still valid and loaded, then we are still valid
var isStillValid = gameObject != null && gameObject.scene.IsValid() && gameObject.scene.isLoaded;
// If we're not the authority and everything is valid and dynamically spawned, then the destroy is not valid.
- if (!isAuthorityDestroy && IsSceneObject == false && isStillValid)
+ if (!isAuthorityDestroy && !InScenePlaced && isStillValid)
{
if (networkManager.LogLevel <= LogLevel.Error)
{
@@ -1778,7 +1834,7 @@ private void OnDestroy()
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
- internal void SpawnInternal(bool destroyWithScene, ulong ownerClientId, bool playerObject)
+ private void SpawnInternal(bool destroyWithScene, ulong ownerClientId, bool playerObject)
{
if (NetworkManagerOwner == null)
{
@@ -1849,7 +1905,37 @@ internal void SpawnInternal(bool destroyWithScene, ulong ownerClientId, bool pla
}
}
- if (!NetworkManagerOwner.SpawnManager.AuthorityLocalSpawn(this, NetworkManagerOwner.SpawnManager.GetNetworkObjectId(), IsSceneObject.HasValue && IsSceneObject.Value, playerObject, ownerClientId, destroyWithScene))
+ // Trap for runtime generated instances as this is not valid
+ if (GlobalObjectIdHash == 0)
+ {
+ NetworkManager.Log.ErrorServer(new Context(LogLevel.Error, $"Detected {nameof(NetworkObject)} {nameof(GlobalObjectIdHash)} value of 0!" +
+ $"This is typically a sign of runtime generated network prefab assets which are not supported.").AddNetworkObject(this));
+ return;
+ }
+
+ // Calculate the legacy IsSceneObject value as the public field is obsolete with warning
+ // We can't break the public behavior of the field.
+#pragma warning disable CS0618 // Type or member is obsolete
+ var legacyIsSceneObject = IsSceneObject.HasValue && IsSceneObject.Value;
+#pragma warning restore CS0618 // Type or member is obsolete
+
+ // If the initial state of the GameObject was disabled and InScenePlaced is marked,
+ // then spawn it as in-scene placed.
+ // Otherwise:
+ // If we are marked as in-scene place, have never been spawned, and the root GameObject
+ // was not disabled upon being instantiated, then treat this as a dynamically spawned
+ // instance.
+ if (InScenePlaced && !m_InScenePlacedDisabledByDefault && !HasBeenSpawned)
+ {
+ if (NetworkManagerOwner.NetworkConfig.EnableSceneManagement && NetworkManagerOwner.LogLevel <= LogLevel.Normal)
+ {
+ Debug.LogWarning($"[{name}][SceneOrigin={SceneOriginHandle}] Dynamically spawning InScenePlaced network object. This can cause issues!", this);
+ }
+
+ InScenePlaced = false;
+ }
+
+ if (!NetworkManagerOwner.SpawnManager.AuthorityLocalSpawn(this, NetworkManagerOwner.SpawnManager.GetNetworkObjectId(), legacyIsSceneObject, playerObject, ownerClientId, destroyWithScene))
{
if (NetworkManagerOwner.LogLevel <= LogLevel.Normal)
{
@@ -1989,8 +2075,7 @@ public NetworkObject InstantiateAndSpawn(NetworkManager networkManager, ulong ow
/// Should the object be destroyed when the scene is changed
public void Spawn(bool destroyWithScene = false)
{
- var networkManager = NetworkManager;
- var clientId = networkManager.DistributedAuthorityMode ? networkManager.LocalClientId : NetworkManager.ServerClientId;
+ var clientId = NetworkManager.DistributedAuthorityMode ? NetworkManager.LocalClientId : NetworkManager.ServerClientId;
SpawnInternal(destroyWithScene, clientId, false);
}
@@ -2042,10 +2127,72 @@ public void Despawn(bool destroy = true)
NetworkManagerOwner.SpawnManager.DespawnObject(this, destroy);
}
+ internal void SetupOnSpawn(ulong networkId, bool isPlayerObject, ulong ownerClientId, bool destroyWithScene)
+ {
+ NetworkObjectId = networkId;
+ IsPlayerObject = isPlayerObject;
+ OwnerClientId = ownerClientId;
+ // When spawned, previous owner is always the first assigned owner
+ PreviousOwnerId = ownerClientId;
+ m_HasAuthority = NetworkManagerOwner.DistributedAuthorityMode ? OwnerClientId == NetworkManagerOwner.LocalClientId : NetworkManagerOwner.IsServer;
+ m_SpawnCount++;
+ IsSpawned = true;
+
+ // If this is the player, and the client is the owner, then lock ownership by default
+ if (NetworkManagerOwner.DistributedAuthorityMode && NetworkManagerOwner.LocalClientId == ownerClientId && isPlayerObject)
+ {
+ AddOwnershipExtended(OwnershipStatusExtended.Locked);
+ }
+
+ if (IsSpawnAuthority)
+ {
+ SetupObservers();
+ }
+
+ /*
+ * Setup scene related settings
+ */
+ DestroyWithScene = InScenePlaced || destroyWithScene;
+ if (InScenePlaced)
+ {
+ // Always check to make sure our scene of origin is properly set for in-scene placed NetworkObjects
+ // Note: Always check SceneOriginHandle directly at this specific location.
+ if (SceneOriginHandle.IsEmpty())
+ {
+ SceneOrigin = gameObject.scene;
+ }
+
+ // If we are an in-scene placed NetworkObject and our InScenePlacedSourceGlobalObjectIdHash is set
+ // then assign this to the PrefabGlobalObjectIdHash
+ if (InScenePlacedSourceGlobalObjectIdHash != 0)
+ {
+ PrefabGlobalObjectIdHash = InScenePlacedSourceGlobalObjectIdHash;
+ }
+ }
+ else if (ActiveSceneSynchronization)
+ {
+ // Just in case it is a recycled NetworkObject, unsubscribe first
+ SceneManager.activeSceneChanged -= CurrentlyActiveSceneChanged;
+ SceneManager.activeSceneChanged += CurrentlyActiveSceneChanged;
+ }
+ }
+
+ ///
+ /// Resets this NetworkObject at the end of a session.
+ /// Ensures scene objects are ready to be reused
+ ///
+ internal void ResetOnShutdown()
+ {
+ NetworkLog.InternalAssert(NetworkManager.ShutdownInProgress, "This method should only be called while the NetworkManager is shutting down");
+ m_SpawnCount = 0;
+ ResetOnDespawn();
+ }
+
internal void ResetOnDespawn()
{
// Always clear out the observers list when despawned
Observers.Clear();
+ m_HasAuthority = false;
IsSpawnAuthority = false;
IsSpawned = false;
DeferredDespawnTick = 0;
@@ -2053,6 +2200,62 @@ internal void ResetOnDespawn()
RemoveOwnershipExtended(OwnershipStatusExtended.Locked | OwnershipStatusExtended.Requested);
}
+ internal void SetupObservers()
+ {
+ NetworkLog.InternalAssert(IsSpawnAuthority, "This function should only be called on the authority.");
+
+ if (!SpawnWithObservers)
+ {
+ if (NetworkManagerOwner.DistributedAuthorityMode)
+ {
+ // Always add the owner/authority in DA mode even if SpawnWithObservers is false
+ // (authority should not take into consideration networkObject.CheckObjectVisibility when SpawnWithObservers is false)
+ AddObserver(OwnerClientId);
+ }
+
+ return;
+ }
+
+ // If running as a server only, then make sure to always add the server's client identifier
+ if (NetworkManagerOwner.IsServer && !NetworkManagerOwner.IsHost)
+ {
+ AddObserver(NetworkManager.ServerClientId);
+ }
+
+ // If SpawnWithObservers is set,
+ // then add all connected clients as observers
+ foreach (var clientId in NetworkManagerOwner.ConnectedClientsIds)
+ {
+ // If CheckObjectVisibility has a callback, then allow that method determine who the observers are.
+ if (CheckObjectVisibility != null && !CheckObjectVisibility(clientId))
+ {
+ continue;
+ }
+ AddObserver(clientId);
+ }
+
+ // Intentionally checking as opposed to just assigning in order to generate notification.
+ if (!Observers.Contains(OwnerClientId))
+ {
+ // The owner only needs to always be included in DA mode.
+ if (NetworkManagerOwner.DistributedAuthorityMode)
+ {
+ if (NetworkManager.LogLevel <= LogLevel.Error)
+ {
+ NetworkLog.LogError($"Client-{OwnerClientId} is the owner of {name} but is not an observer! Adding owner as an observer!");
+ }
+ AddObserver(OwnerClientId);
+ }
+ else
+ {
+ if (NetworkManager.LogLevel <= LogLevel.Developer)
+ {
+ NetworkLog.LogWarning($"Client-{OwnerClientId} is the owner of {name} but is not an observer! This may cause issues");
+ }
+ }
+ }
+ }
+
///
/// Removes all ownership of an object from any client. Can only be called from server
///
@@ -2083,7 +2286,7 @@ public void ChangeOwnership(ulong newOwnerClientId)
}
return;
}
- NetworkManagerOwner.SpawnManager.ChangeOwnership(this, newOwnerClientId, HasAuthority);
+ NetworkManagerOwner.SpawnManager.ChangeOwnership(this, newOwnerClientId, m_HasAuthority);
}
///
@@ -2092,20 +2295,18 @@ public void ChangeOwnership(ulong newOwnerClientId)
///
internal void InvokeBehaviourOnOwnershipChanged(ulong originalOwnerClientId, ulong newOwnerClientId)
{
- if (!IsSpawned)
- {
- if (NetworkManager.LogLevel <= LogLevel.Error)
- {
- NetworkLog.LogErrorServer($"[{name}][Attempted behavior invoke on ownership changed before {nameof(NetworkObject)} was spawned]");
- }
- return;
- }
+ NetworkLog.InternalAssert(IsSpawned, "[{name}][Attempted behavior invoke on ownership changed before {nameof(NetworkObject)} was spawned]");
var distributedAuthorityMode = NetworkManagerOwner.DistributedAuthorityMode;
var isServer = NetworkManagerOwner.IsServer;
var isPreviousOwner = originalOwnerClientId == NetworkManagerOwner.LocalClientId;
var isNewOwner = newOwnerClientId == NetworkManagerOwner.LocalClientId;
+ if (distributedAuthorityMode)
+ {
+ m_HasAuthority = isNewOwner;
+ }
+
if (distributedAuthorityMode || isPreviousOwner)
{
NetworkManagerOwner.SpawnManager.UpdateOwnershipTable(this, originalOwnerClientId, true);
@@ -2318,7 +2519,7 @@ public bool TrySetParent(NetworkObject parent, bool worldPositionStays = true)
// DANGO-TODO: Do we want to worry about ownership permissions here?
// It wouldn't make sense to not allow parenting, but keeping this note here as a reminder.
- var isAuthority = HasAuthority || (AllowOwnerToParent && IsOwner);
+ var isAuthority = m_HasAuthority || (AllowOwnerToParent && IsOwner);
// If we don't have authority and we are not shutting down, then don't allow any parenting.
// If we are shutting down and don't have authority then allow it.
@@ -2393,7 +2594,7 @@ private void OnTransformParentChanged()
// With distributed authority, we need to track "valid authoritative" parenting changes.
// So, either the authority or AuthorityAppliedParenting is considered a "valid parenting change".
- var isParentingAuthority = HasAuthority || AuthorityAppliedParenting || (AllowOwnerToParent && IsOwner);
+ var isParentingAuthority = m_HasAuthority || AuthorityAppliedParenting || (AllowOwnerToParent && IsOwner);
// If we are spawned and don't have authority; reset the parent back to the cached parent and exit
if (!isParentingAuthority)
{
@@ -2506,6 +2707,10 @@ private void OnTransformParentChanged()
// If you couldn't find your parent, we put you into OrphanChildren set and every time we spawn another NetworkObject locally due to replication,
// we call CheckOrphanChildren() method and quickly iterate over OrphanChildren set and see if we can reparent/adopt one.
internal static HashSet OrphanChildren = new HashSet();
+#if UNITY_EDITOR
+ [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+ private static void ResetStaticsOnLoad() => OrphanChildren = new HashSet();
+#endif
internal bool ApplyNetworkParenting(bool removeParent = false, bool ignoreNotSpawned = false, bool orphanedChildPass = false, bool enableNotification = true)
{
@@ -2528,8 +2733,7 @@ internal bool ApplyNetworkParenting(bool removeParent = false, bool ignoreNotSpa
// Handle the first in-scene placed NetworkObject parenting scenarios. Once the m_LatestParent
// has been set, this will not be entered into again (i.e. the later code will be invoked and
// users will get notifications when the parent changes).
- var isInScenePlaced = IsSceneObject.HasValue && IsSceneObject.Value;
- if (transform.parent != null && !removeParent && !m_LatestParent.HasValue && isInScenePlaced)
+ if (transform.parent != null && !removeParent && !m_LatestParent.HasValue && InScenePlaced)
{
var parentNetworkObject = transform.parent.GetComponent();
@@ -2544,8 +2748,8 @@ internal bool ApplyNetworkParenting(bool removeParent = false, bool ignoreNotSpa
m_CachedWorldPositionStays = false;
return true;
}
- else // If the parent still isn't spawned add this to the orphaned children and return false
- if (!parentNetworkObject.IsSpawned)
+ // If the parent still isn't spawned add this to the orphaned children and return false
+ else if (!parentNetworkObject.IsSpawned)
{
OrphanChildren.Add(this);
return false;
@@ -2644,8 +2848,6 @@ internal void InvokeBehaviourNetworkPreSpawn()
internal void InvokeBehaviourNetworkSpawn()
{
- NetworkManagerOwner.SpawnManager.UpdateOwnershipTable(this, OwnerClientId);
-
// Always invoke all InternalOnNetworkSpawn methods on each child NetworkBehaviour
// ** before ** invoking OnNetworkSpawn.
// This assures all NetworkVariables and RPC related tables have been initialized
@@ -2806,17 +3008,31 @@ internal void SynchronizeOwnerNetworkVariables(ulong originalOwnerId, ulong orig
childBehaviour.MarkOwnerReadDirtyAndCheckOwnerWriteIsDirty();
}
+ // If the spawn authority of a distributed authority network topology has invoked a change in ownership,
+ // then we want to invoke the NetworkBehaviourUpdate prior to changing the owner back.
+ if (NetworkManager.DistributedAuthorityMode)
+ {
+ // Force send a state update for all owner read NetworkVariables and any currently dirty
+ // owner write NetworkVariables.
+ NetworkManagerOwner.BehaviourUpdater.NetworkBehaviourUpdate(true);
+ }
+
// Now set the new owner and previous owner identifiers back to their original new values
- // before we run the NetworkBehaviourUpdate. For owner read only permissions this order of
- // operations is **particularly important** as we need to first (above) mark things as dirty
- // from the context of the original owner and then second (below) we need to send the messages
- // which requires the new owner to be set for owner read permission NetworkVariables.
+ // after we run the NetworkBehaviourUpdate.
OwnerClientId = currentOwnerId;
PreviousOwnerId = originalOwnerId;
- // Force send a state update for all owner read NetworkVariables and any currently dirty
- // owner write NetworkVariables.
- NetworkManagerOwner.BehaviourUpdater.NetworkBehaviourUpdate(true);
+ // For owner read only permissions this order of operations is **particularly important** as
+ // we need to first (above) mark things as dirty from the context of the original owner and
+ // then second (below) we need to send the messages which requires the new owner to be set.
+ // Note: Owner read only NetworkVariables do not make sense in a distributed authority topology
+ // since the only instance that can write is the owner.
+ if (!NetworkManager.DistributedAuthorityMode)
+ {
+ // Force send a state update for all owner read NetworkVariables and any currently dirty
+ // owner write NetworkVariables.
+ NetworkManagerOwner.BehaviourUpdater.NetworkBehaviourUpdate(true);
+ }
}
// NGO currently guarantees that the client will receive spawn data for all objects in one network tick.
@@ -3262,7 +3478,12 @@ internal void SynchronizeNetworkBehaviours(ref BufferSerializer serializer
}
}
- internal SerializedObject Serialize(ulong targetClientId = NetworkManager.ServerClientId, bool syncObservers = false)
+ ///
+ /// Creates a on an authority client.
+ /// Used to synchronize state to a non-authority client.
+ ///
+ /// This function is the authority mirror of
+ internal SerializedObject SerializeSpawnedObject(ulong targetClientId = NetworkManager.ServerClientId, bool syncObservers = false)
{
var obj = new SerializedObject
{
@@ -3271,7 +3492,7 @@ internal SerializedObject Serialize(ulong targetClientId = NetworkManager.Server
NetworkObjectId = NetworkObjectId,
OwnerClientId = OwnerClientId,
IsPlayerObject = IsPlayerObject,
- IsSceneObject = IsSceneObject ?? true,
+ IsSceneObject = InScenePlaced,
DestroyWithScene = DestroyWithScene,
DontDestroyWithOwner = DontDestroyWithOwner,
HasOwnershipFlags = NetworkManagerOwner.DistributedAuthorityMode,
@@ -3337,25 +3558,23 @@ internal SerializedObject Serialize(ulong targetClientId = NetworkManager.Server
}
///
- /// Used to deserialize a serialized which occurs
- /// when the client is approved or during a scene transition
+ /// Does a non-authority local spawn of a given .
+ /// This occurs when the client is approved, a new object is spawned by an authority, or during a scene transition.
///
- /// Deserialized scene object data
- /// FastBufferReader for the NetworkVariable data
- /// NetworkManager instance
+ /// This function is the non-authority mirror of
+ /// Deserialized data received from the authority for this
+ /// FastBufferReader for any additional data sent with this object on spawn.
+ /// NetworkManager instance.
/// will be true if invoked by CreateObjectMessage
/// The deserialized NetworkObject or null if deserialization failed
- internal static NetworkObject Deserialize(in SerializedObject serializedObject, FastBufferReader reader, NetworkManager networkManager, bool invokedByMessage = false)
+ [return: MaybeNull]
+ internal static NetworkObject DeserializeAndSpawnObject(in SerializedObject serializedObject, FastBufferReader reader, NetworkManager networkManager, bool invokedByMessage = false)
{
var endOfSynchronizationData = reader.Position + serializedObject.SynchronizationDataSize;
if (serializedObject.NetworkObjectId == default)
{
- if (networkManager.LogLevel <= LogLevel.Error)
- {
- NetworkLog.LogErrorServer($"[{nameof(GlobalObjectIdHash)}={serializedObject.Hash}] Received spawn request with invalid {nameof(NetworkObjectId)} {serializedObject.NetworkObjectId}. This should not happen!");
- }
-
+ NetworkLog.LogErrorServer(new Context(LogLevel.Error, $"Received spawn request with invalid {nameof(NetworkObjectId)}. This should not happen!").AddInfo(nameof(NetworkObjectId), serializedObject.NetworkObjectId).AddInfo(nameof(GlobalObjectIdHash), serializedObject.Hash));
reader.Seek(endOfSynchronizationData);
return null;
}
@@ -3372,7 +3591,8 @@ internal static NetworkObject Deserialize(in SerializedObject serializedObject,
{
if (networkManager.LogLevel <= LogLevel.Normal)
{
- NetworkLog.LogWarning($"[{networkObject.name}][Deserialize][{nameof(NetworkBehaviour)}Synchronization][Size mismatch] Expected: {endOfSynchronizationData} Currently At: {reader.Position}!");
+ var networkObjectName = networkObject != null ? networkObject.name : "null";
+ NetworkLog.LogWarning($"[{networkObjectName}][Deserialize][{nameof(NetworkBehaviour)}Synchronization][Size mismatch] Expected: {endOfSynchronizationData} Currently At: {reader.Position}!");
}
reader.Seek(endOfSynchronizationData);
}
@@ -3446,34 +3666,18 @@ internal static NetworkObject Deserialize(in SerializedObject serializedObject,
return networkObject;
}
- ///
- /// Subscribes to changes in the currently active scene
- ///
- ///
- /// Only for dynamically spawned NetworkObjects
- ///
- internal void SubscribeToActiveSceneForSynch()
- {
- if (ActiveSceneSynchronization)
- {
- if (IsSceneObject.HasValue && !IsSceneObject.Value)
- {
- // Just in case it is a recycled NetworkObject, unsubscribe first
- SceneManager.activeSceneChanged -= CurrentlyActiveSceneChanged;
- SceneManager.activeSceneChanged += CurrentlyActiveSceneChanged;
- }
- }
- }
-
///
/// If AutoSynchActiveScene is enabled, then this is the callback that handles updating
/// a NetworkObject's scene information.
///
+ ///
+ /// Should only be used for dynamically spawned NetworkObjects
+ ///
private void CurrentlyActiveSceneChanged(Scene current, Scene next)
{
// Early exit if the NetworkObject is not spawned, is an in-scene placed NetworkObject,
// or the NetworkManager is shutting down.
- if (!IsSpawned || IsSceneObject != false || NetworkManagerOwner.ShutdownInProgress)
+ if (!IsSpawned || NetworkManagerOwner.ShutdownInProgress || InScenePlaced)
{
return;
}
@@ -3483,7 +3687,7 @@ private void CurrentlyActiveSceneChanged(Scene current, Scene next)
{
// Only dynamically spawned NetworkObjects that are not already in the newly assigned active scene will migrate
// and update their scene handles
- if (IsSceneObject.HasValue && !IsSceneObject.Value && gameObject.scene != next && gameObject.transform.parent == null)
+ if (gameObject.scene != next && gameObject.transform.parent == null)
{
SceneManager.MoveGameObjectToScene(gameObject, next);
SceneChangedUpdate(next);
@@ -3502,20 +3706,20 @@ internal void SceneChangedUpdate(Scene scene, bool notify = false)
return;
}
+ // Don't create notification if there is a scene event in progress.
if (NetworkManagerOwner.SceneManager.IsSceneEventInProgress())
{
return;
}
- var isAuthority = HasAuthority;
SceneOriginHandle = scene.handle;
// non-authority needs to update the NetworkSceneHandle
- if (!isAuthority && NetworkManagerOwner.SceneManager.ClientSceneHandleToServerSceneHandle.ContainsKey(SceneOriginHandle))
+ if (!m_HasAuthority && NetworkManagerOwner.SceneManager.ClientSceneHandleToServerSceneHandle.ContainsKey(SceneOriginHandle))
{
NetworkSceneHandle = NetworkManagerOwner.SceneManager.ClientSceneHandleToServerSceneHandle[SceneOriginHandle];
}
- else if (isAuthority)
+ else if (m_HasAuthority)
{
// Since the authority is the source of truth for the NetworkSceneHandle,
// the NetworkSceneHandle is the same as the SceneOriginHandle.
@@ -3528,8 +3732,8 @@ internal void SceneChangedUpdate(Scene scene, bool notify = false)
NetworkSceneHandle = SceneOriginHandle;
}
}
- else // Otherwise, the client did not find the client to server scene handle
- if (NetworkManagerOwner.LogLevel <= LogLevel.Developer)
+ // Otherwise, the client did not find the client to server scene handle
+ else if (NetworkManagerOwner.LogLevel <= LogLevel.Developer)
{
// There could be a scenario where a user has some client-local scene loaded that they migrate the NetworkObject
// into, but that scenario seemed very edge case and under most instances a user should be notified that this
@@ -3542,17 +3746,13 @@ internal void SceneChangedUpdate(Scene scene, bool notify = false)
OnMigratedToNewScene?.Invoke();
// Only the authority side will notify clients of non-parented NetworkObject scene changes
- if (isAuthority && notify && !transform.parent)
+ if (m_HasAuthority && notify && !transform.parent)
{
NetworkManagerOwner.SceneManager.NotifyNetworkObjectSceneChanged(this);
}
}
- private void Awake()
- {
- SetCachedParent(transform.parent);
- SceneOrigin = gameObject.scene;
- }
+
///
/// Update
@@ -3571,7 +3771,7 @@ internal bool UpdateForSceneChanges()
// the NetworkManager is shutting down, the NetworkObject is not spawned, it is an in-scene placed
// NetworkObject, or the GameObject's current scene handle is the same as the SceneOriginHandle
if (!SceneMigrationSynchronization || !IsSpawned || NetworkManagerOwner.ShutdownInProgress ||
- !NetworkManagerOwner.NetworkConfig.EnableSceneManagement || IsSceneObject != false || !gameObject)
+ !NetworkManagerOwner.NetworkConfig.EnableSceneManagement || InScenePlaced || !gameObject)
{
// Stop checking for a scene migration
return false;
@@ -3606,7 +3806,7 @@ internal uint CheckForGlobalObjectIdHashOverride()
// If scene management is disabled and this is an in-scene placed NetworkObject then go ahead
// and send the InScenePlacedSourcePrefab's GlobalObjectIdHash value (i.e. what to dynamically spawn)
- if (!networkManager.NetworkConfig.EnableSceneManagement && IsSceneObject.Value && InScenePlacedSourceGlobalObjectIdHash != 0)
+ if (!networkManager.NetworkConfig.EnableSceneManagement && InScenePlaced && InScenePlacedSourceGlobalObjectIdHash != 0)
{
return InScenePlacedSourceGlobalObjectIdHash;
}
@@ -3614,7 +3814,7 @@ internal uint CheckForGlobalObjectIdHashOverride()
// If the PrefabGlobalObjectIdHash is a non-zero value and the GlobalObjectIdHash value is
// different from the PrefabGlobalObjectIdHash value, then the NetworkObject instance is
// an override for the original network prefab (i.e. PrefabGlobalObjectIdHash)
- if (!IsSceneObject.Value && GlobalObjectIdHash != PrefabGlobalObjectIdHash)
+ if (!InScenePlaced && GlobalObjectIdHash != PrefabGlobalObjectIdHash)
{
// If the PrefabGlobalObjectIdHash is already populated (i.e. InstantiateAndSpawn used), then return this
if (PrefabGlobalObjectIdHash != 0)
diff --git a/com.unity.netcode.gameobjects/Runtime/Core/NetworkUpdateLoop.cs b/com.unity.netcode.gameobjects/Runtime/Core/NetworkUpdateLoop.cs
index c48dea0333..5ac60e2cd4 100644
--- a/com.unity.netcode.gameobjects/Runtime/Core/NetworkUpdateLoop.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Core/NetworkUpdateLoop.cs
@@ -70,19 +70,19 @@ public enum NetworkUpdateStage : byte
///
public static class NetworkUpdateLoop
{
- private static Dictionary> s_UpdateSystem_Sets;
- private static Dictionary s_UpdateSystem_Arrays;
- private const int k_UpdateSystem_InitialArrayCapacity = 1024;
+ private static Dictionary> s_UpdateSystemSets;
+ private static Dictionary s_UpdateSystemArrays;
+ private const int k_UpdateSystemInitialArrayCapacity = 1024;
static NetworkUpdateLoop()
{
- s_UpdateSystem_Sets = new Dictionary>();
- s_UpdateSystem_Arrays = new Dictionary();
+ s_UpdateSystemSets = new Dictionary>();
+ s_UpdateSystemArrays = new Dictionary();
foreach (NetworkUpdateStage updateStage in Enum.GetValues(typeof(NetworkUpdateStage)))
{
- s_UpdateSystem_Sets.Add(updateStage, new HashSet());
- s_UpdateSystem_Arrays.Add(updateStage, new INetworkUpdateSystem[k_UpdateSystem_InitialArrayCapacity]);
+ s_UpdateSystemSets.Add(updateStage, new HashSet());
+ s_UpdateSystemArrays.Add(updateStage, new INetworkUpdateSystem[k_UpdateSystemInitialArrayCapacity]);
}
}
@@ -105,19 +105,19 @@ public static void RegisterAllNetworkUpdates(this INetworkUpdateSystem updateSys
/// The being registered for the implementation
public static void RegisterNetworkUpdate(this INetworkUpdateSystem updateSystem, NetworkUpdateStage updateStage = NetworkUpdateStage.Update)
{
- var sysSet = s_UpdateSystem_Sets[updateStage];
+ var sysSet = s_UpdateSystemSets[updateStage];
if (!sysSet.Contains(updateSystem))
{
sysSet.Add(updateSystem);
int setLen = sysSet.Count;
- var sysArr = s_UpdateSystem_Arrays[updateStage];
+ var sysArr = s_UpdateSystemArrays[updateStage];
int arrLen = sysArr.Length;
if (setLen > arrLen)
{
// double capacity
- sysArr = s_UpdateSystem_Arrays[updateStage] = new INetworkUpdateSystem[arrLen *= 2];
+ sysArr = s_UpdateSystemArrays[updateStage] = new INetworkUpdateSystem[arrLen *= 2];
}
sysSet.CopyTo(sysArr);
@@ -149,13 +149,13 @@ public static void UnregisterAllNetworkUpdates(this INetworkUpdateSystem updateS
/// The to be deregistered from the implementation
public static void UnregisterNetworkUpdate(this INetworkUpdateSystem updateSystem, NetworkUpdateStage updateStage = NetworkUpdateStage.Update)
{
- var sysSet = s_UpdateSystem_Sets[updateStage];
+ var sysSet = s_UpdateSystemSets[updateStage];
if (sysSet.Contains(updateSystem))
{
sysSet.Remove(updateSystem);
int setLen = sysSet.Count;
- var sysArr = s_UpdateSystem_Arrays[updateStage];
+ var sysArr = s_UpdateSystemArrays[updateStage];
int arrLen = sysArr.Length;
sysSet.CopyTo(sysArr);
@@ -177,7 +177,7 @@ internal static void RunNetworkUpdateStage(NetworkUpdateStage updateStage)
{
UpdateStage = updateStage;
- var sysArr = s_UpdateSystem_Arrays[updateStage];
+ var sysArr = s_UpdateSystemArrays[updateStage];
int arrLen = sysArr.Length;
for (int curIdx = 0; curIdx < arrLen; curIdx++)
{
@@ -291,6 +291,17 @@ public static PlayerLoopSystem CreateLoopSystem()
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
private static void Initialize()
{
+#if UNITY_EDITOR
+ // Reset statics
+ s_UpdateSystemSets = new Dictionary>();
+ s_UpdateSystemArrays = new Dictionary();
+ foreach (NetworkUpdateStage updateStage in Enum.GetValues(typeof(NetworkUpdateStage)))
+ {
+ s_UpdateSystemSets.Add(updateStage, new HashSet());
+ s_UpdateSystemArrays.Add(updateStage, new INetworkUpdateSystem[k_UpdateSystemInitialArrayCapacity]);
+ }
+ UpdateStage = default;
+#endif
UnregisterLoopSystems();
RegisterLoopSystems();
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Logging/ContextualLogger.cs b/com.unity.netcode.gameobjects/Runtime/Logging/ContextualLogger.cs
index 006f919ce1..3141a2a3bf 100644
--- a/com.unity.netcode.gameobjects/Runtime/Logging/ContextualLogger.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Logging/ContextualLogger.cs
@@ -60,7 +60,7 @@ public ContextualLogger(Object inspectorObject, [NotNull] NetworkManager network
}
/// Used for the NetworkLog
- internal ContextualLogger(NetworkManager networkManager, bool useCompatibilityMode)
+ internal ContextualLogger(NetworkManager networkManager, bool useCompatibilityMode = false)
{
m_UseCompatibilityMode = useCompatibilityMode;
m_ManagerContext = new LogContextNetworkManager(networkManager);
@@ -89,7 +89,7 @@ internal DisposableContext AddDisposableInfo(string key, object value)
[Conditional(k_CompilationCondition)]
internal void RemoveInfo(string key)
{
- m_LoggerContext.ClearInfo(key);
+ m_LoggerContext.RemoveInfo(key);
}
[HideInCallstack]
@@ -125,6 +125,19 @@ public void Exception(Exception exception)
{
Debug.unityLogger.LogException(exception, m_Object);
}
+ [HideInCallstack]
+ public void Exception(Exception exception, Context context)
+ {
+ // Don't act if the LogLevel is higher than the level of this log
+ if (m_ManagerContext.LogLevel > context.Level)
+ {
+ return;
+ }
+
+ var message = BuildLog(context);
+ Debug.unityLogger.LogException(new Exception(message, exception), context.RelevantObjectOverride ?? m_Object);
+ }
+
[HideInCallstack]
private void Log(LogType logType, Context context)
diff --git a/com.unity.netcode.gameobjects/Runtime/Logging/LogBuilder.cs b/com.unity.netcode.gameobjects/Runtime/Logging/LogBuilder.cs
index 0c59e10bd4..c8f8c1ba25 100644
--- a/com.unity.netcode.gameobjects/Runtime/Logging/LogBuilder.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Logging/LogBuilder.cs
@@ -31,6 +31,7 @@ public void AppendInfo(object key, object value)
}
public void Append(string value) => m_Builder.Append(value);
+ public void AppendLine(string value) => m_Builder.AppendLine(value);
public string Build() => m_Builder.ToString();
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Logging/LogContext.cs b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext.cs
deleted file mode 100644
index 8c6cbd0bf1..0000000000
--- a/com.unity.netcode.gameobjects/Runtime/Logging/LogContext.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-using System.Runtime.CompilerServices;
-using Object = UnityEngine.Object;
-
-namespace Unity.Netcode.Logging
-{
- internal interface ILogContext
- {
- public void AppendTo(LogBuilder builder)
- {
- }
- }
-
- internal struct Context : ILogContext
- {
- public readonly LogLevel Level;
- private readonly string m_CallingFunction;
- internal readonly string Message;
- internal Object RelevantObjectOverride;
-
- private readonly GenericContext m_Other;
-
- public Context(LogLevel level, string msg, [CallerMemberName] string memberName = "")
- {
- Level = level;
- Message = msg;
- m_CallingFunction = memberName;
-
- m_Other = GenericContext.Create();
- RelevantObjectOverride = null;
- }
-
- internal Context(LogLevel level, string msg, bool noCaller)
- {
- Level = level;
- Message = msg;
- m_CallingFunction = null;
-
- m_Other = GenericContext.Create();
- RelevantObjectOverride = null;
- }
-
- public void AppendTo(LogBuilder builder)
- {
- // [CallingFunction]
- if (!string.IsNullOrEmpty(m_CallingFunction))
- {
- builder.AppendTag(m_CallingFunction);
- }
-
- // [SomeContext][SomeName:SomeValue]
- m_Other.AppendTo(builder);
-
- // Human-readable log message
- builder.Append(" ");
- builder.Append(Message);
- }
-
- public Context AddInfo(object key, object value)
- {
- m_Other.StoreInfo(key, value);
- return this;
- }
-
- public Context AddTag(string msg)
- {
- m_Other.StoreTag(msg);
- return this;
- }
-
- public Context AddObject(Object obj)
- {
- RelevantObjectOverride = obj;
- return this;
- }
- }
-}
diff --git a/com.unity.netcode.gameobjects/Runtime/Logging/LogContext.meta b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext.meta
new file mode 100644
index 0000000000..7c7f21c305
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1a57adef9bcf4768866c1e922dff4ad1
+timeCreated: 1779217887
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/CollectionContext.cs b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/CollectionContext.cs
new file mode 100644
index 0000000000..70c493950d
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/CollectionContext.cs
@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+
+namespace Unity.Netcode.Logging
+{
+ internal delegate string LogCollectionBuilder(TItem item);
+ internal readonly struct CollectionContext : ILogContext
+ {
+ private readonly LogCollectionBuilder m_Delegate;
+ private readonly IEnumerable m_Collection;
+
+ public CollectionContext(IEnumerable collection, LogCollectionBuilder builder)
+ {
+ m_Delegate = builder;
+ m_Collection = collection;
+ }
+
+ public void AppendTo(LogBuilder builder)
+ {
+ foreach (var item in m_Collection)
+ {
+ builder.AppendLine(m_Delegate(item));
+ }
+ }
+ }
+}
diff --git a/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/CollectionContext.cs.meta b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/CollectionContext.cs.meta
new file mode 100644
index 0000000000..5323a6eda2
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/CollectionContext.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f64de1e86c70433e96280f0c8af6e8f6
+timeCreated: 1779214517
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Runtime/Logging/GenericContext.cs b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/GenericContext.cs
similarity index 78%
rename from com.unity.netcode.gameobjects/Runtime/Logging/GenericContext.cs
rename to com.unity.netcode.gameobjects/Runtime/Logging/LogContext/GenericContext.cs
index 47d198f447..643ec30324 100644
--- a/com.unity.netcode.gameobjects/Runtime/Logging/GenericContext.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/GenericContext.cs
@@ -5,20 +5,20 @@ namespace Unity.Netcode.Logging
{
internal readonly struct GenericContext : ILogContext, IDisposable
{
- private readonly List m_Contexts;
+ private readonly List m_Tags;
private readonly Dictionary m_Info;
- private GenericContext(List contexts, Dictionary info)
+ private GenericContext(List tags, Dictionary info)
{
- m_Contexts = contexts;
+ m_Tags = tags;
m_Info = info;
}
public void AppendTo(LogBuilder builder)
{
- if (m_Contexts != null)
+ if (m_Tags != null)
{
- foreach (var ctx in m_Contexts)
+ foreach (var ctx in m_Tags)
{
builder.AppendTag(ctx);
}
@@ -33,9 +33,9 @@ public void AppendTo(LogBuilder builder)
}
}
- public void StoreTag(string msg)
+ public void StoreTag(string tag)
{
- m_Contexts.Add(msg);
+ m_Tags.Add(tag);
}
public void StoreInfo(object key, object value)
@@ -43,11 +43,16 @@ public void StoreInfo(object key, object value)
m_Info.Add(key, value);
}
- public void ClearInfo(object key)
+ public void RemoveInfo(object key)
{
m_Info?.Remove(key);
}
+ public void RemoveTag(string tag)
+ {
+ m_Tags?.Remove(tag);
+ }
+
public void Dispose()
{
PreallocatedStore.Free(this);
@@ -76,7 +81,7 @@ internal static GenericContext GetPreallocated()
internal static void Free(GenericContext ctx)
{
- ctx.m_Contexts.Clear();
+ ctx.m_Tags.Clear();
ctx.m_Info.Clear();
k_Preallocated.Enqueue(ctx);
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Logging/GenericContext.cs.meta b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/GenericContext.cs.meta
similarity index 100%
rename from com.unity.netcode.gameobjects/Runtime/Logging/GenericContext.cs.meta
rename to com.unity.netcode.gameobjects/Runtime/Logging/LogContext/GenericContext.cs.meta
diff --git a/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContext.cs b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContext.cs
new file mode 100644
index 0000000000..a36b6b91fb
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContext.cs
@@ -0,0 +1,169 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using Object = UnityEngine.Object;
+
+namespace Unity.Netcode.Logging
+{
+ internal interface ILogContext
+ {
+ public void AppendTo(LogBuilder builder);
+ }
+
+ internal struct Context : ILogContext, IDisposable
+ {
+ public readonly LogLevel Level;
+ private readonly string m_CallingFunction;
+ internal readonly string Message;
+ internal Object RelevantObjectOverride;
+
+ private readonly GenericContext m_Other;
+ private List m_Prepend;
+ private List m_Postpend;
+
+ public Context(LogLevel level, string msg, [CallerMemberName] string memberName = "")
+ {
+ Level = level;
+ Message = msg;
+ m_CallingFunction = memberName;
+
+ m_Other = GenericContext.Create();
+ RelevantObjectOverride = null;
+ m_Prepend = null;
+ m_Postpend = null;
+ }
+
+ internal Context(LogLevel level, string msg, bool noCaller)
+ {
+ Level = level;
+ Message = msg;
+ m_CallingFunction = null;
+
+ m_Other = GenericContext.Create();
+ RelevantObjectOverride = null;
+ m_Prepend = null;
+ m_Postpend = null;
+ }
+
+ public void AppendTo(LogBuilder builder)
+ {
+ // [CallingFunction]
+ if (!string.IsNullOrEmpty(m_CallingFunction))
+ {
+ builder.AppendTag(m_CallingFunction);
+ }
+
+
+ // [SomeContext][SomeName:SomeValue]
+ m_Other.AppendTo(builder);
+
+ if (m_Prepend != null)
+ {
+ foreach (var context in m_Prepend)
+ {
+ context.AppendTo(builder);
+ }
+ }
+
+ // Human-readable log message
+ builder.Append(" ");
+ builder.Append(Message);
+
+ if (m_Postpend != null)
+ {
+ foreach (var context in m_Postpend)
+ {
+ context.AppendTo(builder);
+ }
+ }
+ }
+
+ public Context AddInfo(object key, object value)
+ {
+ m_Other.StoreInfo(key, value);
+ return this;
+ }
+
+ public Context AddTag(string msg)
+ {
+ m_Other.StoreTag(msg);
+ return this;
+ }
+
+ public Context AddObject(Object obj)
+ {
+ RelevantObjectOverride = obj;
+ return this;
+ }
+
+ public Context AddNetworkObject(NetworkObject networkObject)
+ {
+ AddPrepend(new LogContextNetworkObject(networkObject));
+ RelevantObjectOverride = networkObject;
+ return this;
+ }
+
+ public Context AddNetworkBehaviour(NetworkBehaviour networkBehaviour)
+ {
+ AddPrepend(new LogContextNetworkBehaviour(networkBehaviour));
+ RelevantObjectOverride = networkBehaviour;
+ return this;
+ }
+
+ public Context AddCollection(IEnumerable collection, LogCollectionBuilder builder)
+ {
+ AddPostpend(new CollectionContext(collection, builder));
+ return this;
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ private void AddPrepend(ILogContext prepend)
+ {
+ if (m_Prepend == null)
+ {
+ m_Prepend = PreallocatedStore.GetPreallocated();
+ }
+ m_Prepend.Add(prepend);
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ private void AddPostpend(ILogContext postpend)
+ {
+ if (m_Postpend == null)
+ {
+ m_Postpend = PreallocatedStore.GetPreallocated();
+ }
+ m_Postpend.Add(postpend);
+ }
+
+ public void Dispose()
+ {
+ m_Other.Dispose();
+ PreallocatedStore.Free(m_Prepend);
+ PreallocatedStore.Free(m_Postpend);
+ m_Prepend = null;
+ m_Postpend = null;
+ }
+
+ private static class PreallocatedStore
+ {
+ private static readonly Queue> k_Preallocated = new();
+
+ internal static List GetPreallocated()
+ {
+ if (k_Preallocated.Count > 0)
+ {
+ k_Preallocated.Dequeue();
+ }
+
+ return new List();
+ }
+
+ internal static void Free(List collection)
+ {
+ collection.Clear();
+ k_Preallocated.Enqueue(collection);
+ }
+ }
+ }
+}
diff --git a/com.unity.netcode.gameobjects/Runtime/Logging/LogContext.cs.meta b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContext.cs.meta
similarity index 100%
rename from com.unity.netcode.gameobjects/Runtime/Logging/LogContext.cs.meta
rename to com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContext.cs.meta
diff --git a/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContextNetworkBehaviour.cs b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContextNetworkBehaviour.cs
new file mode 100644
index 0000000000..149fd001ff
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContextNetworkBehaviour.cs
@@ -0,0 +1,21 @@
+namespace Unity.Netcode.Logging
+{
+ internal readonly struct LogContextNetworkBehaviour : ILogContext
+ {
+ private readonly NetworkBehaviour m_NetworkBehaviour;
+
+ public LogContextNetworkBehaviour(NetworkBehaviour networkBehaviour)
+ {
+ m_NetworkBehaviour = networkBehaviour;
+ }
+
+ public void AppendTo(LogBuilder builder)
+ {
+ builder.AppendTag(m_NetworkBehaviour.gameObject.name);
+ if (m_NetworkBehaviour.IsSpawned)
+ {
+ builder.AppendInfo(nameof(NetworkBehaviour.NetworkBehaviourId), m_NetworkBehaviour.NetworkBehaviourId);
+ }
+ }
+ }
+}
diff --git a/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContextNetworkBehaviour.cs.meta b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContextNetworkBehaviour.cs.meta
new file mode 100644
index 0000000000..a4f9cae7ed
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContextNetworkBehaviour.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ce875bd203c24cf1b916741eac3a55f8
+timeCreated: 1779217913
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Runtime/Logging/LogContextNetworkManager.cs b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContextNetworkManager.cs
similarity index 100%
rename from com.unity.netcode.gameobjects/Runtime/Logging/LogContextNetworkManager.cs
rename to com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContextNetworkManager.cs
diff --git a/com.unity.netcode.gameobjects/Runtime/Logging/LogContextNetworkManager.cs.meta b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContextNetworkManager.cs.meta
similarity index 100%
rename from com.unity.netcode.gameobjects/Runtime/Logging/LogContextNetworkManager.cs.meta
rename to com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContextNetworkManager.cs.meta
diff --git a/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContextNetworkObject.cs b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContextNetworkObject.cs
new file mode 100644
index 0000000000..d7feb201b1
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContextNetworkObject.cs
@@ -0,0 +1,21 @@
+namespace Unity.Netcode.Logging
+{
+ internal readonly struct LogContextNetworkObject : ILogContext
+ {
+ private readonly NetworkObject m_NetworkObject;
+
+ public LogContextNetworkObject(NetworkObject networkObject)
+ {
+ m_NetworkObject = networkObject;
+ }
+
+ public void AppendTo(LogBuilder builder)
+ {
+ builder.AppendTag(m_NetworkObject.name);
+ if (m_NetworkObject.IsSpawned)
+ {
+ builder.AppendInfo(nameof(NetworkObject.NetworkObjectId), m_NetworkObject.NetworkObjectId);
+ }
+ }
+ }
+}
diff --git a/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContextNetworkObject.cs.meta b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContextNetworkObject.cs.meta
new file mode 100644
index 0000000000..9c98d47b80
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Runtime/Logging/LogContext/LogContextNetworkObject.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d6f400599d664e92a747913ca672e02e
+timeCreated: 1779217114
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Runtime/Logging/NetworkLog.cs b/com.unity.netcode.gameobjects/Runtime/Logging/NetworkLog.cs
index 29a092e77d..66a7df1f96 100644
--- a/com.unity.netcode.gameobjects/Runtime/Logging/NetworkLog.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Logging/NetworkLog.cs
@@ -1,18 +1,26 @@
+using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Text.RegularExpressions;
using Unity.Netcode.Logging;
using UnityEngine;
+using UnityEngine.Assertions;
namespace Unity.Netcode
{
+ ///
+ /// Log configuration containing :
+ /// - used in LogContextNetworkManager.cs
+ /// - used in SceneEventData.cs
+ ///
internal struct LogConfiguration
{
internal bool LogNetworkManagerRole;
+ internal bool LogSerializationOrder;
}
///
- /// Helper class for logging
+ /// Helper class for logging.
///
public static class NetworkLog
{
@@ -58,7 +66,7 @@ internal static void ConfigureIntegrationTestLogging(NetworkManager networkManag
internal static void LogWarning(Context context) => s_Log.Warning(context);
///
- /// Locally logs a error log with Netcode prefixing.
+ /// Locally logs an error log with Netcode prefixing.
///
/// The message to log
[HideInCallstack]
@@ -95,6 +103,8 @@ internal static void ConfigureIntegrationTestLogging(NetworkManager networkManag
/// The message to log
[HideInCallstack]
public static void LogErrorServer(string message) => s_Log.ErrorServer(new Context(LogLevel.Error, message, true));
+ [HideInCallstack]
+ internal static void LogErrorServer(Context context) => s_Log.ErrorServer(context);
internal static LogType GetMessageLogType(UnityEngine.LogType engineLogType)
{
@@ -107,14 +117,14 @@ internal static LogType GetMessageLogType(UnityEngine.LogType engineLogType)
};
}
-
private const string k_SenderId = "SenderId";
internal static Context BuildContextForServerMessage([NotNull] NetworkManager networkManager, LogLevel level, ulong senderId, string message)
{
- var ctx = new Context(level, message, true).AddInfo(k_SenderId, senderId);
- if (TryGetNetworkObjectName(networkManager, message, out var name))
+ var ctx = new Context(level, message, true).AddTag("Received log from client").AddInfo(k_SenderId, senderId);
+ var networkObject = TryGetNetworkObject(networkManager, message);
+ if (networkObject != null)
{
- ctx.AddTag(name);
+ ctx.AddNetworkObject(networkObject);
}
return ctx;
}
@@ -127,30 +137,48 @@ internal enum LogType : byte
None
}
- private static readonly Regex k_GlobalObjectIdHash = new($@"\[{nameof(NetworkObject.GlobalObjectIdHash)}=(\d+)\]", RegexOptions.Compiled);
+ private static readonly Regex k_NetworkObjectId = new($@"\[{nameof(NetworkObject.NetworkObjectId)}:(\d+)\]", RegexOptions.Compiled);
+ private static readonly Regex k_GlobalObjectIdHash = new($@"\[{nameof(NetworkObject.GlobalObjectIdHash)}:(\d+)\]", RegexOptions.Compiled);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
- private static bool TryGetNetworkObjectName([NotNull] NetworkManager networkManager, string message, out string name)
+ private static NetworkObject TryGetNetworkObject([NotNull] NetworkManager networkManager, string message)
{
- name = null;
+ if (k_NetworkObjectId.IsMatch(message))
+ {
+ var stringId = k_NetworkObjectId.Match(message).Groups[1].Value;
+ if (ulong.TryParse(stringId, out var networkObjectId) && networkObjectId > 0 && networkManager.SpawnManager.SpawnedObjects.TryGetValue(networkObjectId, out var networkObject))
+ {
+ return networkObject;
+ }
+ }
+
if (!k_GlobalObjectIdHash.IsMatch(message))
{
- return false;
+ return null;
}
var stringHash = k_GlobalObjectIdHash.Match(message).Groups[1].Value;
if (!ulong.TryParse(stringHash, out var globalObjectIdHash))
{
- return false;
+ return null;
}
- if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(globalObjectIdHash, out var networkObject))
+ NetworkObject matchingObject = null;
+ foreach (var networkObject in networkManager.SpawnManager.SpawnedObjectsList)
{
- return false;
+ if (networkObject.GlobalObjectIdHash == globalObjectIdHash)
+ {
+ matchingObject = networkObject;
+ }
}
- name = networkObject.name;
- return true;
+ return matchingObject;
}
+ [HideInCallstack]
+ [Conditional("NETCODE_INTERNAL")]
+ internal static void InternalAssert(bool condition, string message)
+ {
+ Assert.IsTrue(condition, message);
+ }
}
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/CustomMessageManager.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/CustomMessageManager.cs
index 15e30205f8..58a1f93470 100644
--- a/com.unity.netcode.gameobjects/Runtime/Messaging/CustomMessageManager.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Messaging/CustomMessageManager.cs
@@ -434,7 +434,7 @@ public void SendNamedMessage(string messageName, IReadOnlyList clientIds,
/// Exception thrown in case validation fails
private unsafe void ValidateMessageSize(FastBufferWriter messageStream, NetworkDelivery networkDelivery, bool isNamed)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
var maxNonFragmentedSize = m_NetworkManager.MessageManager.NonFragmentedMessageMaxSize - FastBufferWriter.GetWriteSize() - sizeof(NetworkBatchHeader);
if (isNamed)
{
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/DeferredMessageManager.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/DeferredMessageManager.cs
index f05d000fec..4d0cd8fec8 100644
--- a/com.unity.netcode.gameobjects/Runtime/Messaging/DeferredMessageManager.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Messaging/DeferredMessageManager.cs
@@ -96,6 +96,10 @@ public virtual unsafe void CleanupStaleTriggers()
/// Used for testing purposes
///
internal static bool IncludeMessageType = true;
+#if UNITY_EDITOR
+ [UnityEngine.RuntimeInitializeOnLoadMethod(UnityEngine.RuntimeInitializeLoadType.SubsystemRegistration)]
+ private static void ResetStaticsOnLoad() => IncludeMessageType = true;
+#endif
private string GetWarningMessage(IDeferredNetworkMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo, float spawnTimeout)
{
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/ILPPMessageProvider.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/ILPPMessageProvider.cs
index ec460cc821..8d8379dc05 100644
--- a/com.unity.netcode.gameobjects/Runtime/Messaging/ILPPMessageProvider.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Messaging/ILPPMessageProvider.cs
@@ -53,6 +53,10 @@ internal struct ILPPMessageProvider : INetworkMessageProvider
// Enable this for integration tests that need no message types defined
internal static bool IntegrationTestNoMessages;
+#if UNITY_EDITOR
+ [UnityEngine.RuntimeInitializeOnLoadMethod(UnityEngine.RuntimeInitializeLoadType.SubsystemRegistration)]
+ private static void ResetStaticsOnLoad() => IntegrationTestNoMessages = false;
+#endif
///
/// Returns a table of message type to NetworkMessageTypes enum value
@@ -144,6 +148,7 @@ internal static Dictionary GetMessageTypesMap()
[InitializeOnLoadMethod]
public static void NotifyOnPlayStateChange()
{
+ EditorApplication.playModeStateChanged -= OnPlayModeStateChanged;
EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/INetworkMessage.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/INetworkMessage.cs
index fe481d25f5..7417bd6b85 100644
--- a/com.unity.netcode.gameobjects/Runtime/Messaging/INetworkMessage.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Messaging/INetworkMessage.cs
@@ -1,4 +1,3 @@
-
namespace Unity.Netcode
{
///
@@ -45,8 +44,10 @@ internal interface INetworkMessage
public int Version { get; }
}
-
- internal static class MessageDeliveryType where T : INetworkMessage
+#if UNITY_6000_6_OR_NEWER
+ [Scripting.LifecycleManagement.AutoStaticsCleanup]
+#endif
+ internal static partial class MessageDeliveryType where T : INetworkMessage
{
internal static NetworkDelivery DefaultDelivery { get; private set; }
internal static void Initialize()
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/MessageDelivery.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/MessageDelivery.cs
index e8cf2ca6db..cc54d9d102 100644
--- a/com.unity.netcode.gameobjects/Runtime/Messaging/MessageDelivery.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Messaging/MessageDelivery.cs
@@ -1,7 +1,6 @@
using System;
using System.Collections.Generic;
using Unity.Netcode;
-using UnityEditor;
using UnityEngine;
internal static class MessageDelivery
@@ -15,17 +14,21 @@ internal static class MessageDelivery
/// when sending the message via public API.
/// - Skip the time sync messages since it has always used unreliable network delivery.
///
- private static HashSet s_SkipMessageTypes = new HashSet(){
+ private static readonly HashSet k_SkipMessageTypes = new HashSet(){
NetworkMessageTypes.NamedMessage, NetworkMessageTypes.Unnamed};
- [RuntimeInitializeOnLoadMethod]
+ [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
private static void OnApplicationStart()
{
+#if UNITY_EDITOR
+ s_MessageToDelivery = new Dictionary();
+ s_MessageToMessageType = new Dictionary();
+#endif
UpdateMessageTypes();
}
///
- /// FIrst pass at providing an easier path to configuring the network
+ /// First pass at providing an easier path to configuring the network
/// delivery type for the message type.
/// TODO: Once coalesces all reliable messages
/// and/or organizes by a more unified order of operation tracking built into the
@@ -40,7 +43,7 @@ private static void UpdateMessageTypes()
foreach (var messageTypeObject in networkMessageTypes)
{
var messageType = (NetworkMessageTypes)messageTypeObject;
- if (s_SkipMessageTypes.Contains(messageType))
+ if (k_SkipMessageTypes.Contains(messageType))
{
continue;
}
@@ -56,9 +59,13 @@ private static void UpdateMessageTypes()
MessageDeliveryType.Initialize();
MessageDeliveryType.Initialize();
MessageDeliveryType.Initialize();
+ MessageDeliveryType.Initialize();
+ MessageDeliveryType.Initialize();
+ MessageDeliveryType.Initialize();
MessageDeliveryType.Initialize();
MessageDeliveryType.Initialize();
MessageDeliveryType.Initialize();
+ MessageDeliveryType.Initialize();
// RpcMessage.cs
{
MessageDeliveryType.Initialize();
@@ -71,18 +78,10 @@ private static void UpdateMessageTypes()
MessageDeliveryType.Initialize();
}
-#if UNITY_EDITOR
- [InitializeOnLoadMethod]
- [InitializeOnEnterPlayMode]
- private static void OnEnterPlayMode()
- {
- UpdateMessageTypes();
- }
-#endif
internal static NetworkDelivery GetDelivery(Type type)
{
// Return the default if not registered or null
- if (type == null || s_SkipMessageTypes.Contains(s_MessageToMessageType[type]))
+ if (type == null || k_SkipMessageTypes.Contains(s_MessageToMessageType[type]))
{
return NetworkDelivery.ReliableFragmentedSequenced;
}
@@ -91,7 +90,7 @@ internal static NetworkDelivery GetDelivery(Type type)
internal static NetworkDelivery GetDelivery(NetworkMessageTypes messageType)
{
- if (s_SkipMessageTypes.Contains(messageType))
+ if (k_SkipMessageTypes.Contains(messageType))
{
throw new Exception($"{messageType} is not registered in the message type to network delivery map!");
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/ConnectionApprovedMessage.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/ConnectionApprovedMessage.cs
index 17669a335f..2a7eee8be7 100644
--- a/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/ConnectionApprovedMessage.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/ConnectionApprovedMessage.cs
@@ -160,7 +160,7 @@ public void Serialize(FastBufferWriter writer, int targetVersion)
{
sobj.AddObserver(OwnerClientId);
// In distributed authority mode, we send the currently known observers of each NetworkObject to the client being synchronized.
- var serializedObject = sobj.Serialize(OwnerClientId, IsDistributedAuthority);
+ var serializedObject = sobj.SerializeSpawnedObject(OwnerClientId, IsDistributedAuthority);
serializedObject.Serialize(writer);
++sceneObjectCount;
}
@@ -344,7 +344,7 @@ public void Handle(ref NetworkContext context)
{
var serializedObject = new NetworkObject.SerializedObject();
serializedObject.Deserialize(m_ReceivedSceneObjectData);
- NetworkObject.Deserialize(serializedObject, m_ReceivedSceneObjectData, networkManager);
+ NetworkObject.DeserializeAndSpawnObject(serializedObject, m_ReceivedSceneObjectData, networkManager);
}
if (networkManager.DistributedAuthorityMode && networkManager.AutoSpawnPlayerPrefabClientSide)
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/CreateObjectMessage.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/CreateObjectMessage.cs
index cf518a6216..a5f3039251 100644
--- a/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/CreateObjectMessage.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/CreateObjectMessage.cs
@@ -1,5 +1,6 @@
using System.Linq;
using System.Runtime.CompilerServices;
+using Unity.Netcode.Logging;
namespace Unity.Netcode
{
@@ -171,7 +172,12 @@ internal static void CreateObject(ref NetworkManager networkManager, ulong sende
{
if (!networkManager.DistributedAuthorityMode)
{
- networkObject = NetworkObject.Deserialize(serializedObject, networkVariableData, networkManager);
+ networkObject = NetworkObject.DeserializeAndSpawnObject(serializedObject, networkVariableData, networkManager);
+ if (networkObject == null)
+ {
+ networkManager.Log.ErrorServer(new Context(LogLevel.Developer, $"Failed to deserialize {nameof(NetworkObject)}.").AddInfo(nameof(NetworkObject.GlobalObjectIdHash), serializedObject.Hash).AddInfo(nameof(NetworkObject.NetworkObjectId), serializedObject.NetworkObjectId));
+ return;
+ }
}
else
{
@@ -179,25 +185,27 @@ internal static void CreateObject(ref NetworkManager networkManager, ulong sende
var hasNewObserverIdList = newObserverIds != null && newObserverIds.Length > 0;
// Depending upon visibility of the NetworkObject and the client in question, it could be that
// this client already has visibility of this NetworkObject
- if (networkManager.SpawnManager.SpawnedObjects.ContainsKey(serializedObject.NetworkObjectId))
+ if (networkManager.SpawnManager.SpawnedObjects.TryGetValue(serializedObject.NetworkObjectId, out networkObject))
{
- // If so, then just get the local instance
- networkObject = networkManager.SpawnManager.SpawnedObjects[serializedObject.NetworkObjectId];
-
// This should not happen, logging error just in case
if (hasNewObserverIdList && newObserverIds.Contains(networkManager.LocalClientId))
{
NetworkLog.LogErrorServer($"[{nameof(CreateObjectMessage)}][Duplicate-Broadcast] Detected duplicated object creation for {serializedObject.NetworkObjectId}!");
}
- else // Trap to make sure the owner is not receiving any messages it sent
- if (networkManager.CMBServiceConnection && networkManager.LocalClientId == networkObject.OwnerClientId)
+ // Trap to make sure the owner is not receiving any messages it sent
+ else if (networkManager.CMBServiceConnection && networkManager.LocalClientId == networkObject.OwnerClientId)
{
NetworkLog.LogWarning($"[{nameof(CreateObjectMessage)}][Client-{networkManager.LocalClientId}][Duplicate-CreateObjectMessage][Client Is Owner] Detected duplicated object creation for {networkObject.name}-{serializedObject.NetworkObjectId}!");
}
}
else
{
- networkObject = NetworkObject.Deserialize(serializedObject, networkVariableData, networkManager, true);
+ networkObject = NetworkObject.DeserializeAndSpawnObject(serializedObject, networkVariableData, networkManager, true);
+ if (networkObject == null)
+ {
+ networkManager.Log.ErrorServer(new Context(LogLevel.Developer, $"Failed to deserialize {nameof(NetworkObject)}.").AddInfo(nameof(NetworkObject.GlobalObjectIdHash), serializedObject.Hash).AddInfo(nameof(NetworkObject.NetworkObjectId), serializedObject.NetworkObjectId));
+ return;
+ }
}
// DA - NGO CMB SERVICE NOTES:
@@ -214,27 +222,6 @@ internal static void CreateObject(ref NetworkManager networkManager, ulong sende
// Mock CMB Service and forward to all clients
if (networkManager.DAHost)
{
- // DA - NGO CMB SERVICE NOTES:
- // (*** See above notes fist ***)
- // If it is a player object freshly spawning and one or more clients all connect at the exact same time (i.e. received on effectively
- // the same frame), then we need to check the observers list to make sure all players are visible upon first spawning. At a later date,
- // for area of interest we will need to have some form of follow up "observer update" message to cull out players not within each
- // player's AOI.
- if (networkObject.IsPlayerObject && hasNewObserverIdList && clientList.Count != observerIds.Length)
- {
- // For same-frame newly spawned players that might not be aware of all other players, update the player's observer
- // list.
- observerIds = clientList.ToArray();
- }
-
- var createObjectMessage = new CreateObjectMessage()
- {
- ObjectInfo = serializedObject,
- m_ReceivedNetworkVariableData = networkVariableData,
- ObserverIds = hasObserverIdList ? observerIds : null,
- NetworkObjectId = networkObject.NetworkObjectId,
- IncludesSerializedObject = true,
- };
foreach (var clientId in clientList)
{
// DA - NGO CMB SERVICE NOTES:
@@ -250,16 +237,12 @@ internal static void CreateObject(ref NetworkManager networkManager, ulong sende
// If this included a list of new observers and the targeted clientId is one of the observers, then send the serialized data.
// Otherwise, the targeted clientId has already has visibility (i.e. it is already spawned) and so just send the updated
// observers list to that client's instance.
- createObjectMessage.IncludesSerializedObject = hasNewObserverIdList && newObserverIds.Contains(clientId);
-
networkManager.SpawnManager.SendSpawnCallForObject(clientId, networkObject);
}
}
}
- if (networkObject != null)
- {
- networkManager.NetworkMetrics.TrackObjectSpawnReceived(senderId, networkObject, messageSize);
- }
+
+ networkManager.NetworkMetrics.TrackObjectSpawnReceived(senderId, networkObject, messageSize);
}
catch (System.Exception ex)
{
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs
index 11fe2e2a7e..3e4c6a0541 100644
--- a/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs
@@ -47,7 +47,7 @@ internal struct NetworkVariableDeltaMessage : INetworkMessage
private Dictionary> m_ForwardUpdates;
- private List m_UpdatedNetworkVariables;
+ private NativeList m_UpdatedNetworkVariables;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void WriteNetworkVariable(ref FastBufferWriter writer, ref NetworkVariableBase networkVariable, bool ensureNetworkVariableLengthSafety, int nonfragmentedSize, int fragmentedSize)
@@ -217,7 +217,7 @@ public void Handle(ref NetworkContext context)
var networkBehaviour = networkObject.GetNetworkBehaviourAtOrderIndex(NetworkBehaviourIndex);
var isServerAndDeltaForwarding = m_ReceivedMessageVersion >= k_ServerDeltaForwardingAndNetworkDelivery && networkManager.IsServer;
var markNetworkVariableDirty = m_ReceivedMessageVersion >= k_ServerDeltaForwardingAndNetworkDelivery ? false : networkManager.IsServer;
- m_UpdatedNetworkVariables = new List();
+ m_UpdatedNetworkVariables = new NativeList(Allocator.Temp);
if (networkBehaviour == null)
{
@@ -396,9 +396,9 @@ public void Handle(ref NetworkContext context)
// When a server forwards delta updates to connected clients, it needs to preserve the previous value
// until it is done serializing all valid NetworkVariable field deltas (relative to each client). This
// is invoked after it is done forwarding the deltas.
- foreach (var fieldIndex in m_UpdatedNetworkVariables)
+ for (int i = 0; i < m_UpdatedNetworkVariables.Length; i++)
{
- networkBehaviour.NetworkVariableFields[fieldIndex].PostDeltaRead();
+ networkBehaviour.NetworkVariableFields[m_UpdatedNetworkVariables[i]].PostDeltaRead();
}
}
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/RpcMessages.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/RpcMessages.cs
index c8be0c251d..0dbb3b6bf6 100644
--- a/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/RpcMessages.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/RpcMessages.cs
@@ -1,6 +1,6 @@
using System;
using Unity.Collections;
-using UnityEngine;
+using Unity.Netcode.Logging;
namespace Unity.Netcode
{
@@ -16,80 +16,75 @@ public static unsafe void Serialize(ref FastBufferWriter writer, ref RpcMetadata
public static unsafe bool Deserialize(ref FastBufferReader reader, ref NetworkContext context, ref RpcMetadata metadata, ref FastBufferReader payload, string messageType)
{
+ var networkManager = (NetworkManager)context.SystemOwner;
ByteUnpacker.ReadValueBitPacked(reader, out metadata.NetworkObjectId);
- ByteUnpacker.ReadValueBitPacked(reader, out metadata.NetworkBehaviourId);
- ByteUnpacker.ReadValueBitPacked(reader, out metadata.NetworkRpcMethodId);
- var networkManager = (NetworkManager)context.SystemOwner;
- if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(metadata.NetworkObjectId))
+ if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(metadata.NetworkObjectId, out var networkObject))
{
+ networkManager.Log.Info(new Context(LogLevel.Developer, $"Received RPC message for {nameof(NetworkObject)} that doesn't exist yet. Deferring the message.").AddInfo("SenderClientId", context.SenderId).AddInfo(nameof(NetworkObject.NetworkObjectId), metadata.NetworkObjectId).AddInfo(nameof(RpcMetadata.NetworkRpcMethodId), metadata.NetworkRpcMethodId));
networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, metadata.NetworkObjectId, reader, ref context, messageType);
return false;
}
- var networkObject = networkManager.SpawnManager.SpawnedObjects[metadata.NetworkObjectId];
- var networkBehaviour = networkManager.SpawnManager.SpawnedObjects[metadata.NetworkObjectId].GetNetworkBehaviourAtOrderIndex(metadata.NetworkBehaviourId);
- if (networkBehaviour == null)
- {
- return false;
- }
-
- if (!NetworkBehaviour.__rpc_func_table[networkBehaviour.GetType()].ContainsKey(metadata.NetworkRpcMethodId))
- {
- return false;
- }
+ ByteUnpacker.ReadValueBitPacked(reader, out metadata.NetworkBehaviourId);
+ ByteUnpacker.ReadValueBitPacked(reader, out metadata.NetworkRpcMethodId);
payload = new FastBufferReader(reader.GetUnsafePtrAtCurrentPosition(), Allocator.None, reader.Length - reader.Position);
-#if MULTIPLAYER_TOOLS && (DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
- networkBehaviour.TrackRpcMetricsReceive(ref metadata, ref context, reader.Length);
-#endif
return true;
}
public static void Handle(ref NetworkContext context, ref RpcMetadata metadata, ref FastBufferReader payload, ref __RpcParams rpcParams)
{
var networkManager = (NetworkManager)context.SystemOwner;
+
if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(metadata.NetworkObjectId, out var networkObject))
{
// If the NetworkObject no longer exists then just log a warning when developer mode logging is enabled and exit.
// This can happen if NetworkObject is despawned and a client sends an RPC before receiving the despawn message.
- if (networkManager.LogLevel == LogLevel.Developer)
- {
- NetworkLog.LogWarning($"[{metadata.NetworkObjectId}, {metadata.NetworkBehaviourId}, {metadata.NetworkRpcMethodId}] An RPC called on a {nameof(NetworkObject)} that is not in the spawned objects list. Please make sure the {nameof(NetworkObject)} is spawned before calling RPCs.");
- }
-
+ networkManager.Log.Warning(new Context(LogLevel.Developer, $"Received RPC message for {nameof(NetworkObject)} that doesn't exist yet. Deferring the message.").AddInfo(nameof(NetworkObject.NetworkObjectId), metadata.NetworkObjectId).AddInfo(nameof(RpcMetadata.NetworkRpcMethodId), metadata.NetworkRpcMethodId));
return;
}
var networkBehaviour = networkObject.GetNetworkBehaviourAtOrderIndex(metadata.NetworkBehaviourId);
- try
+ if (networkBehaviour == null)
{
- var permission = NetworkBehaviour.__rpc_permission_table[networkBehaviour.GetType()][metadata.NetworkRpcMethodId];
+ networkManager.Log.Error(new Context(LogLevel.Normal, $"Received RPC message for {nameof(NetworkBehaviour)} that doesn't exist. Dropping RPC message").AddNetworkObject(networkObject).AddInfo(nameof(NetworkBehaviour.NetworkBehaviourId), networkBehaviour.NetworkBehaviourId));
+ return;
+ }
- if ((permission == RpcInvokePermission.Server && rpcParams.SenderId != NetworkManager.ServerClientId) ||
- (permission == RpcInvokePermission.Owner && rpcParams.SenderId != networkObject.OwnerClientId))
- {
- if (networkManager.LogLevel <= LogLevel.Developer)
- {
- NetworkLog.LogErrorServer($"Rpc message received from client-{rpcParams.SenderId} who does not have permission to perform this operation!");
- }
- return;
- }
+ var type = networkBehaviour.GetType();
+ if (!NetworkBehaviour.__rpc_func_table.TryGetValue(type, out var rpcsForBehaviour) || !NetworkBehaviour.__rpc_permission_table.TryGetValue(type, out var permissionsTable))
+ {
+ networkManager.Log.Error(new Context(LogLevel.Normal, $"Rpc table doesn't have RPCs registered for this {nameof(NetworkBehaviour)}. Dropping RPC message").AddNetworkObject(networkObject).AddInfo(nameof(NetworkBehaviour.NetworkBehaviourId), networkBehaviour.NetworkBehaviourId).AddInfo(nameof(NetworkBehaviour), type));
+ return;
+ }
+ if (!rpcsForBehaviour.TryGetValue(metadata.NetworkRpcMethodId, out var receiveHandler) || !permissionsTable.TryGetValue(metadata.NetworkRpcMethodId, out var permission))
+ {
+ networkManager.Log.Error(new Context(LogLevel.Normal, "Received RPC message for RPC receiver that doesn't exist. Dropping RPC message").AddNetworkBehaviour(networkBehaviour).AddInfo(nameof(RpcMetadata.NetworkRpcMethodId), metadata.NetworkRpcMethodId));
+ return;
+ }
- NetworkBehaviour.__rpc_func_table[networkBehaviour.GetType()][metadata.NetworkRpcMethodId](networkBehaviour, payload, rpcParams);
+ if ((permission == RpcInvokePermission.Server && rpcParams.SenderId != NetworkManager.ServerClientId) ||
+ (permission == RpcInvokePermission.Owner && rpcParams.SenderId != networkObject.OwnerClientId))
+ {
+ networkManager.Log.ErrorServer(new Context(LogLevel.Normal, "Rpc message received from a client without permission to perform this operation!. Dropping RPC message").AddNetworkBehaviour(networkBehaviour));
+ return;
+ }
+
+#if MULTIPLAYER_TOOLS && (DEBUG || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
+ networkBehaviour.TrackRpcMetricsReceive(ref metadata, ref context, payload.Length);
+#endif
+
+ try
+ {
+ receiveHandler(networkBehaviour, payload, rpcParams);
}
catch (Exception ex)
{
- Debug.LogException(new Exception($"Unhandled RPC exception!", ex));
- if (networkManager.LogLevel <= LogLevel.Developer)
- {
- Debug.Log($"RPC Table Contents");
- foreach (var entry in NetworkBehaviour.__rpc_func_table[networkBehaviour.GetType()])
- {
- var permission = NetworkBehaviour.__rpc_permission_table[networkBehaviour.GetType()][metadata.NetworkRpcMethodId];
- Debug.Log($"{entry.Key} | {entry.Value.Method.Name} | {permission}");
- }
- }
+ networkManager.Log.Exception(ex, new Context(LogLevel.Error, "Unhandled RPC exception!").AddNetworkBehaviour(networkBehaviour));
+
+ var invokePermission = permission;
+ networkManager.Log.Info(new Context(LogLevel.Developer, "RPC Table Contents").AddCollection(rpcsForBehaviour, entry => $"{entry.Key} | {entry.Value.Method.Name} | {invokePermission}"));
}
}
}
@@ -270,12 +265,12 @@ public void Handle(ref NetworkContext context)
}
catch (Exception ex)
{
- Debug.LogException(ex);
+ networkManager.Log.Exception(ex);
}
}
else
{
- NetworkLog.LogErrorServer($"Received {nameof(ForwardServerRpcMessage)} on client-{networkManager.LocalClientId}! Only DAHost may forward RPC messages!");
+ networkManager.Log.ErrorServer(new Context(LogLevel.Error, $"Received {nameof(ForwardServerRpcMessage)} when not the DAHost! Only DAHost may forward RPC messages!").AddInfo("SenderClientId", context.SenderId));
}
ServerRpcMessage.ReadBuffer.Dispose();
ServerRpcMessage.WriteBuffer.Dispose();
@@ -351,7 +346,7 @@ public void Handle(ref NetworkContext context)
}
else
{
- NetworkLog.LogErrorServer($"Received {nameof(ForwardClientRpcMessage)} on client-{networkManager.LocalClientId}! Only DAHost may forward RPC messages!");
+ networkManager.Log.ErrorServer(new Context(LogLevel.Error, $"Received {nameof(ForwardClientRpcMessage)} when not the DAHost! Only DAHost may forward RPC messages!").AddInfo("SenderClientId", context.SenderId));
}
ClientRpcMessage.WriteBuffer.Dispose();
ClientRpcMessage.ReadBuffer.Dispose();
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/NetworkMessageManager.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/NetworkMessageManager.cs
index c66aa62273..21df4c7e4b 100644
--- a/com.unity.netcode.gameobjects/Runtime/Messaging/NetworkMessageManager.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Messaging/NetworkMessageManager.cs
@@ -34,9 +34,9 @@ public InvalidMessageStructureException(string issue) : base(issue)
internal class NetworkMessageManager : IDisposable
{
public bool StopProcessing = false;
- private static Type s_ConnectionApprovedType = typeof(ConnectionApprovedMessage);
- private static Type s_ConnectionRequestType = typeof(ConnectionRequestMessage);
- private static Type s_DisconnectReasonType = typeof(DisconnectReasonMessage);
+ private static readonly Type k_ConnectionApprovedType = typeof(ConnectionApprovedMessage);
+ private static readonly Type k_ConnectionRequestType = typeof(ConnectionRequestMessage);
+ private static readonly Type k_DisconnectReasonType = typeof(DisconnectReasonMessage);
private struct ReceiveQueueItem
{
@@ -149,8 +149,6 @@ public NetworkMessageManager(INetworkMessageSender sender, object owner, INetwor
}
}
- internal static bool EnableMessageOrderConsoleLog = false;
-
public void Dispose()
{
if (m_Disposed)
@@ -505,9 +503,9 @@ internal void CleanupDisconnectedClients()
m_DisconnectedClients.Clear();
}
- public static int CreateMessageAndGetVersion() where T : INetworkMessage, new()
+ public static int CreateMessageAndGetVersion() where T : struct, INetworkMessage
{
- return new T().Version;
+ return default(T).Version;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -540,16 +538,16 @@ internal int GetMessageVersion(Type type, ulong clientId, bool forReceive = fals
- public static void ReceiveMessage(FastBufferReader reader, ref NetworkContext context, NetworkMessageManager manager) where T : INetworkMessage, new()
+ public static void ReceiveMessage(FastBufferReader reader, ref NetworkContext context, NetworkMessageManager manager) where T : struct, INetworkMessage
{
var messageType = typeof(T);
- var message = new T();
+ var message = default(T);
var messageVersion = 0;
// Special cases because these are the messages that carry the version info - thus the version info isn't
// populated yet when we get these. The first part of these messages always has to be the version data
// and can't change.
- if (messageType != s_ConnectionRequestType && messageType != s_ConnectionApprovedType && messageType != s_DisconnectReasonType && context.SenderId != manager.m_LocalClientId)
+ if (messageType != k_ConnectionRequestType && messageType != k_ConnectionApprovedType && messageType != k_DisconnectReasonType && context.SenderId != manager.m_LocalClientId)
{
messageVersion = manager.GetMessageVersion(messageType, context.SenderId, true);
if (messageVersion < 0)
@@ -603,7 +601,7 @@ internal int SendMessage(ref TMessageType messa
var messageVersion = 0;
// Special case because this is the message that carries the version info - thus the version info isn't populated yet when we get this.
// The first part of this message always has to be the version data and can't change.
- if (typeof(TMessageType) != s_ConnectionRequestType)
+ if (typeof(TMessageType) != k_ConnectionRequestType)
{
messageVersion = GetMessageVersion(typeof(TMessageType), clientIds[i]);
if (messageVersion < 0)
@@ -635,8 +633,9 @@ internal int SendMessage(ref TMessageType messa
return largestSerializedSize;
}
- internal unsafe int SendPreSerializedMessage(in FastBufferWriter tmpSerializer, int maxSize, ref TMessageType message, NetworkDelivery delivery, in IReadOnlyList clientIds, int messageVersionFilter)
+ internal unsafe int SendPreSerializedMessage(in FastBufferWriter tmpSerializer, int maxSize, ref TMessageType message, NetworkDelivery delivery, in TClientIdListType clientIds, int messageVersionFilter)
where TMessageType : INetworkMessage
+ where TClientIdListType : IReadOnlyList
{
using var headerSerializer = new FastBufferWriter(FastBufferWriter.GetWriteSize(), Allocator.Temp);
@@ -657,7 +656,7 @@ internal unsafe int SendPreSerializedMessage(in FastBufferWriter t
// Special case because this is the message that carries the version info - thus the version info isn't populated yet when we get this.
// The first part of this message always has to be the version data and can't change.
- if (typeof(TMessageType) != s_ConnectionRequestType)
+ if (typeof(TMessageType) != k_ConnectionRequestType)
{
var messageVersion = GetMessageVersion(typeof(TMessageType), clientIds[i]);
if (messageVersion < 0)
@@ -741,7 +740,7 @@ internal unsafe int SendPreSerializedMessage(in FastBufferWriter t
// Special case because this is the message that carries the version info - thus the version info isn't
// populated yet when we get this. The first part of this message always has to be the version data
// and can't change.
- if (typeof(TMessageType) != s_ConnectionRequestType)
+ if (typeof(TMessageType) != k_ConnectionRequestType)
{
messageVersion = GetMessageVersion(typeof(TMessageType), clientId);
if (messageVersion < 0)
@@ -851,7 +850,7 @@ internal unsafe void ProcessSendQueues()
}
queueItem.Writer.Seek(0);
-#if UNITY_EDITOR || DEVELOPMENT_BUILD
+#if DEBUG
// Skipping the Verify and sneaking the write mark in because we know it's fine.
queueItem.Writer.Handle->AllowedWriteMark = sizeof(NetworkBatchHeader);
#endif
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/BaseRpcTarget.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/BaseRpcTarget.cs
index a1e12a5310..a1b5b5d8aa 100644
--- a/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/BaseRpcTarget.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/BaseRpcTarget.cs
@@ -53,7 +53,7 @@ protected void CheckLockBeforeDispose()
private protected void SendMessageToClient(NetworkBehaviour behaviour, ulong clientId, ref RpcMessage message, NetworkDelivery delivery)
{
var size = behaviour.NetworkManager.MessageManager.SendMessage(ref message, delivery, clientId);
-#if MULTIPLAYER_TOOLS && (DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
+#if MULTIPLAYER_TOOLS && (DEBUG || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
// Send to a specific client
behaviour.TrackRpcMetricsSend(clientId, ref message, size);
#endif
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/LocalSendRpcTarget.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/LocalSendRpcTarget.cs
index 386af8816f..4afa621d11 100644
--- a/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/LocalSendRpcTarget.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/LocalSendRpcTarget.cs
@@ -46,7 +46,7 @@ internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message,
message.Handle(ref context);
length = tempBuffer.Length;
}
-#if MULTIPLAYER_TOOLS && (DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
+#if MULTIPLAYER_TOOLS && (DEBUG || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
// Local invocation sends to self
behaviour.TrackRpcMetricsSend(m_NetworkManager.LocalClientId, ref message, length);
#endif
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/ProxyRpcTargetGroup.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/ProxyRpcTargetGroup.cs
index 8dd2e744eb..40321b3742 100644
--- a/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/ProxyRpcTargetGroup.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/ProxyRpcTargetGroup.cs
@@ -24,7 +24,7 @@ internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message,
}
var proxyMessage = new ProxyMessage { Delivery = delivery, TargetClientIds = TargetClientIds.AsArray(), WrappedMessage = message };
var size = behaviour.NetworkManager.MessageManager.SendMessage(ref proxyMessage, delivery, NetworkManager.ServerClientId);
-#if MULTIPLAYER_TOOLS && (DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
+#if MULTIPLAYER_TOOLS && (DEBUG || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
foreach (var clientId in TargetClientIds)
{
behaviour.TrackRpcMetricsSend(clientId, ref message, size);
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/RpcTarget.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/RpcTarget.cs
index 02fbe958e9..dd10eddc68 100644
--- a/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/RpcTarget.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/RpcTarget.cs
@@ -51,7 +51,7 @@ public enum SendTo
///
NotMe,
///
- /// Send this RPC to everone, filtered to the current observer list.
+ /// Send this RPC to everyone, filtered to the current observer list.
/// Will execute locally.
///
Everyone,
@@ -220,7 +220,7 @@ public void Dispose()
public BaseRpcTarget NotMe;
///
- /// Send this RPC to everone, filtered to the current observer list.
+ /// Send this RPC to everyone, filtered to the current observer list.
/// Will execute locally.
///
public BaseRpcTarget Everyone;
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/ServerRpcTarget.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/ServerRpcTarget.cs
index 63380ce40c..7382b41153 100644
--- a/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/ServerRpcTarget.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Messaging/RpcTargets/ServerRpcTarget.cs
@@ -36,7 +36,7 @@ internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message,
using var tempBuffer = new FastBufferReader(message.WriteBuffer, Allocator.None);
message.ReadBuffer = tempBuffer;
message.Handle(ref context);
-#if MULTIPLAYER_TOOLS && (DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
+#if MULTIPLAYER_TOOLS && (DEBUG || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE)
// Local invocation sends to self
behaviour.TrackRpcMetricsSend(m_NetworkManager.LocalClientId, ref message, tempBuffer.Length);
#endif
diff --git a/com.unity.netcode.gameobjects/Runtime/Metrics/MetricHooks.cs b/com.unity.netcode.gameobjects/Runtime/Metrics/MetricHooks.cs
index fd12bc5adc..c7badc20a0 100644
--- a/com.unity.netcode.gameobjects/Runtime/Metrics/MetricHooks.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Metrics/MetricHooks.cs
@@ -1,10 +1,12 @@
using System;
+using System.Collections.Generic;
namespace Unity.Netcode
{
internal class MetricHooks : INetworkHooks
{
private readonly NetworkManager m_NetworkManager;
+ private readonly Dictionary m_CachedTypeNames = new();
public MetricHooks(NetworkManager networkManager)
{
@@ -17,12 +19,12 @@ public void OnBeforeSendMessage(ulong clientId, ref T message, NetworkDeliver
public void OnAfterSendMessage(ulong clientId, ref T message, NetworkDelivery delivery, int messageSizeBytes) where T : INetworkMessage
{
- m_NetworkManager.NetworkMetrics.TrackNetworkMessageSent(clientId, typeof(T).Name, messageSizeBytes);
+ m_NetworkManager.NetworkMetrics.TrackNetworkMessageSent(clientId, GetNameForType(typeof(T)), messageSizeBytes);
}
public void OnBeforeReceiveMessage(ulong senderId, Type messageType, int messageSizeBytes)
{
- m_NetworkManager.NetworkMetrics.TrackNetworkMessageReceived(senderId, messageType.Name, messageSizeBytes);
+ m_NetworkManager.NetworkMetrics.TrackNetworkMessageReceived(senderId, GetNameForType(messageType), messageSizeBytes);
}
public void OnAfterReceiveMessage(ulong senderId, Type messageType, int messageSizeBytes)
@@ -66,5 +68,22 @@ public void OnAfterHandleMessage(ref T message, ref NetworkContext context) w
{
// TODO: Per-message metrics recording moved here
}
+
+ ///
+ /// Gets the Name from a given type.
+ ///
+ private string GetNameForType(Type type)
+ {
+ if (m_CachedTypeNames.TryGetValue(type, out var cachedName))
+ {
+ return cachedName;
+ }
+
+ // type.Name does a reflection lookup that does a GC allocation
+ // Grab the name once and save to a cache.
+ var name = type.Name;
+ m_CachedTypeNames.Add(type, name);
+ return name;
+ }
}
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Metrics/NetworkMetrics.cs b/com.unity.netcode.gameobjects/Runtime/Metrics/NetworkMetrics.cs
index b171932103..4bb7bb20a0 100644
--- a/com.unity.netcode.gameobjects/Runtime/Metrics/NetworkMetrics.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Metrics/NetworkMetrics.cs
@@ -11,26 +11,22 @@ namespace Unity.Netcode
internal class NetworkMetrics : INetworkMetrics
{
private const ulong k_MaxMetricsPerFrame = 1000L;
- private static Dictionary s_SceneEventTypeNames;
- private static ProfilerMarker s_FrameDispatch = new ProfilerMarker($"{nameof(NetworkMetrics)}.DispatchFrame");
+ private static readonly Dictionary k_SceneEventTypeNames;
+ private static readonly ProfilerMarker k_FrameDispatch;
static NetworkMetrics()
{
- s_SceneEventTypeNames = new Dictionary();
+ k_SceneEventTypeNames = new Dictionary();
foreach (SceneEventType type in Enum.GetValues(typeof(SceneEventType)))
{
- s_SceneEventTypeNames[(uint)type] = type.ToString();
+ k_SceneEventTypeNames[(uint)type] = type.ToString();
}
+ k_FrameDispatch = new ProfilerMarker($"{nameof(NetworkMetrics)}.DispatchFrame");
}
private static string GetSceneEventTypeName(uint typeCode)
{
- if (!s_SceneEventTypeNames.TryGetValue(typeCode, out string name))
- {
- name = "Unknown";
- }
-
- return name;
+ return k_SceneEventTypeNames.GetValueOrDefault(typeCode, "Unknown");
}
private readonly Counter m_TransportBytesSent = new Counter(NetworkMetricTypes.TotalBytesSent.Id)
@@ -511,9 +507,9 @@ public void UpdatePacketLoss(float packetLoss)
public void DispatchFrame()
{
- s_FrameDispatch.Begin();
+ k_FrameDispatch.Begin();
Dispatcher.Dispatch();
- s_FrameDispatch.End();
+ k_FrameDispatch.End();
m_NumberOfMetricsThisFrame = 0;
}
diff --git a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Collections/NetworkList.cs b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Collections/NetworkList.cs
index aafeeb2ab4..acf139b0d1 100644
--- a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Collections/NetworkList.cs
+++ b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Collections/NetworkList.cs
@@ -137,6 +137,15 @@ public override void WriteDelta(FastBufferWriter writer)
}
}
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ private T ReadValue(FastBufferReader reader)
+ {
+ // T is constrained to unmanaged, use default rather than new() to avoid an allocation.
+ var value = default(T);
+ NetworkVariableSerialization.Serializer.Read(reader, ref value);
+ return value;
+ }
+
///
public override void WriteField(FastBufferWriter writer)
{
@@ -154,9 +163,7 @@ public override void ReadField(FastBufferReader reader)
reader.ReadValueSafe(out ushort count);
for (int i = 0; i < count; i++)
{
- var value = new T();
- NetworkVariableSerialization.Serializer.Read(reader, ref value);
- m_List.Add(value);
+ m_List.Add(ReadValue(reader));
}
}
@@ -178,8 +185,7 @@ public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
{
case NetworkListEvent.EventType.Add:
{
- var value = new T();
- NetworkVariableSerialization.Serializer.Read(reader, ref value);
+ var value = ReadValue(reader);
m_List.Add(value);
if (OnListChanged != null)
@@ -188,7 +194,7 @@ public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
{
Type = eventType,
Index = m_List.Length - 1,
- Value = m_List[m_List.Length - 1]
+ Value = value
});
}
@@ -198,7 +204,7 @@ public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
{
Type = eventType,
Index = m_List.Length - 1,
- Value = m_List[m_List.Length - 1]
+ Value = value
});
// Preserve the legacy way of handling this
if (keepDirtyDelta)
@@ -211,8 +217,7 @@ public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
case NetworkListEvent.EventType.Insert:
{
ByteUnpacker.ReadValueBitPacked(reader, out int index);
- var value = new T();
- NetworkVariableSerialization.Serializer.Read(reader, ref value);
+ var value = ReadValue(reader);
if (index < m_List.Length)
{
@@ -230,7 +235,7 @@ public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
{
Type = eventType,
Index = index,
- Value = m_List[index]
+ Value = value
});
}
@@ -240,7 +245,7 @@ public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
{
Type = eventType,
Index = index,
- Value = m_List[index]
+ Value = value
});
// Preserve the legacy way of handling this
if (keepDirtyDelta)
@@ -252,8 +257,7 @@ public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
break;
case NetworkListEvent.EventType.Remove:
{
- var value = new T();
- NetworkVariableSerialization.Serializer.Read(reader, ref value);
+ var value = ReadValue(reader);
int index = m_List.IndexOf(value);
if (index == -1)
{
@@ -323,8 +327,7 @@ public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
case NetworkListEvent.EventType.Value:
{
ByteUnpacker.ReadValueBitPacked(reader, out int index);
- var value = new T();
- NetworkVariableSerialization.Serializer.Read(reader, ref value);
+ var value = ReadValue(reader);
if (index >= m_List.Length)
{
throw new Exception("Shouldn't be here, index is higher than list length");
@@ -683,14 +686,8 @@ private void HandleAddListEvent(NetworkListEvent listEvent)
///
/// This method should not be used. It is left over from a previous interface
///
- public int LastModifiedTick
- {
- get
- {
- // todo: implement proper network tick for NetworkList
- return NetworkTickSystem.NoTick;
- }
- }
+ [Obsolete("This property is no longer used and will be removed in a future version.")]
+ public int LastModifiedTick => NetworkTickSystem.NoTick;
///
/// Overridden implementation.
diff --git a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/CollectionSerializationUtility.cs b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/CollectionSerializationUtility.cs
index d9327f2441..7c1769d9d8 100644
--- a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/CollectionSerializationUtility.cs
+++ b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/CollectionSerializationUtility.cs
@@ -6,7 +6,7 @@
namespace Unity.Netcode
{
- internal static class CollectionSerializationUtility
+ internal static partial class CollectionSerializationUtility
{
public static void WriteNativeArrayDelta(FastBufferWriter writer, ref NativeArray value, ref NativeArray previousValue) where T : unmanaged
{
@@ -260,24 +260,24 @@ public static void ReadListDelta(FastBufferReader reader, ref List value)
// so we're going to keep static lists that we can reuse in these methods.
private static class ListCache
{
- private static List s_AddedList = new List();
- private static List s_RemovedList = new List();
- private static List s_ChangedList = new List();
+ private static readonly List k_AddedList = new List();
+ private static readonly List k_RemovedList = new List();
+ private static readonly List k_ChangedList = new List();
public static List GetAddedList()
{
- s_AddedList.Clear();
- return s_AddedList;
+ k_AddedList.Clear();
+ return k_AddedList;
}
public static List GetRemovedList()
{
- s_RemovedList.Clear();
- return s_RemovedList;
+ k_RemovedList.Clear();
+ return k_RemovedList;
}
public static List GetChangedList()
{
- s_ChangedList.Clear();
- return s_ChangedList;
+ k_ChangedList.Clear();
+ return k_ChangedList;
}
}
diff --git a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/NetworkVariableSerialization.cs b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/NetworkVariableSerialization.cs
index 1a00d2c86a..0c5528ca66 100644
--- a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/NetworkVariableSerialization.cs
+++ b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/NetworkVariableSerialization.cs
@@ -12,6 +12,8 @@ namespace Unity.Netcode
[Serializable]
public static class NetworkVariableSerialization
{
+ // This is all setup in ILPP (in the file NetworkBehaviorILPP), using the functions in TypedILPPInitializers.
+ // There is no need to reset statics here.
internal static INetworkVariableSerializer Serializer = new FallbackSerializer();
///
diff --git a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/TypedSerializerImplementations.cs b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/TypedSerializerImplementations.cs
index e1242378dd..00dd2978b6 100644
--- a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/TypedSerializerImplementations.cs
+++ b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/TypedSerializerImplementations.cs
@@ -243,11 +243,23 @@ public void Read(FastBufferReader reader, ref T value)
public void WriteDelta(FastBufferWriter writer, ref T value, ref T previousValue)
{
+ if (UserNetworkVariableSerialization.WriteDelta != null && UserNetworkVariableSerialization.ReadDelta != null)
+ {
+ UserNetworkVariableSerialization.WriteDelta(writer, value, previousValue);
+ return;
+ }
+
Write(writer, ref value);
}
public void ReadDelta(FastBufferReader reader, ref T value)
{
+ if (UserNetworkVariableSerialization.WriteDelta != null && UserNetworkVariableSerialization.ReadDelta != null)
+ {
+ UserNetworkVariableSerialization.ReadDelta(reader, ref value);
+ return;
+ }
+
Read(reader, ref value);
}
@@ -258,6 +270,12 @@ void INetworkVariableSerializer.ReadWithAllocator(FastBufferReader reader, ou
public void Duplicate(in T value, ref T duplicatedValue)
{
+ if (UserNetworkVariableSerialization.DuplicateValue != null)
+ {
+ UserNetworkVariableSerialization.DuplicateValue(value, ref duplicatedValue);
+ return;
+ }
+
duplicatedValue = value;
}
}
@@ -959,6 +977,12 @@ void INetworkVariableSerializer.ReadWithAllocator(FastBufferReader reader, ou
public void Duplicate(in T value, ref T duplicatedValue)
{
+ if (UserNetworkVariableSerialization.DuplicateValue != null)
+ {
+ UserNetworkVariableSerialization.DuplicateValue(value, ref duplicatedValue);
+ return;
+ }
+
duplicatedValue = value;
}
}
@@ -1128,6 +1152,12 @@ void INetworkVariableSerializer.ReadWithAllocator(FastBufferReader reader, ou
public void Duplicate(in T value, ref T duplicatedValue)
{
+ if (UserNetworkVariableSerialization.DuplicateValue != null)
+ {
+ UserNetworkVariableSerialization.DuplicateValue(value, ref duplicatedValue);
+ return;
+ }
+
using var writer = new FastBufferWriter(256, Allocator.Temp, int.MaxValue);
var refValue = value;
Write(writer, ref refValue);
diff --git a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/UserNetworkVariableSerialization.cs b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/UserNetworkVariableSerialization.cs
index 3f2a64585c..fe6a7acbba 100644
--- a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/UserNetworkVariableSerialization.cs
+++ b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/UserNetworkVariableSerialization.cs
@@ -7,7 +7,10 @@ namespace Unity.Netcode
/// users to tell NetworkVariable about those extension methods (or simply pass in a lambda)
///
/// The type of value being serialized
- public class UserNetworkVariableSerialization
+#if UNITY_6000_6_OR_NEWER
+ [Scripting.LifecycleManagement.AutoStaticsCleanup]
+#endif
+ public partial class UserNetworkVariableSerialization
{
///
/// The write value delegate handler definition
diff --git a/com.unity.netcode.gameobjects/Runtime/SceneManagement/DefaultSceneManagerHandler.cs b/com.unity.netcode.gameobjects/Runtime/SceneManagement/DefaultSceneManagerHandler.cs
index 5a11a01b4a..f7ce87d521 100644
--- a/com.unity.netcode.gameobjects/Runtime/SceneManagement/DefaultSceneManagerHandler.cs
+++ b/com.unity.netcode.gameobjects/Runtime/SceneManagement/DefaultSceneManagerHandler.cs
@@ -206,7 +206,7 @@ public void PopulateLoadedScenes(ref Dictionary scene
/// Unloads any scenes that have not been assigned.
///
///
- public void UnloadUnassignedScenes(NetworkManager networkManager = null)
+ public void UnloadUnassignedScenes(NetworkManager networkManager)
{
var sceneManager = networkManager.SceneManager;
SceneManager.sceneUnloaded += SceneManager_SceneUnloaded;
@@ -311,7 +311,7 @@ public void MoveObjectsFromSceneToDontDestroyOnLoad(ref NetworkManager networkMa
if (!networkObject.DestroyWithScene && networkObject.gameObject.scene != networkManager.SceneManager.DontDestroyOnLoadScene)
{
// Only move dynamically spawned NetworkObjects with no parent as the children will follow
- if (networkObject.gameObject.transform.parent == null && networkObject.IsSceneObject != null && !networkObject.IsSceneObject.Value)
+ if (networkObject.gameObject.transform.parent == null && !networkObject.InScenePlaced)
{
UnityEngine.Object.DontDestroyOnLoad(networkObject.gameObject);
}
@@ -359,8 +359,8 @@ public void SetClientSynchronizationMode(ref NetworkManager networkManager, Load
}
return;
}
- else // Warn users if they are changing this after there are clients already connected and synchronized
- if (!networkManager.DistributedAuthorityMode && networkManager.ConnectedClientsIds.Count > (networkManager.IsHost ? 1 : 0) && sceneManager.ClientSynchronizationMode != mode)
+ // Warn users if they are changing this after there are clients already connected and synchronized
+ else if (!networkManager.DistributedAuthorityMode && networkManager.ConnectedClientsIds.Count > (networkManager.IsHost ? 1 : 0) && sceneManager.ClientSynchronizationMode != mode)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
diff --git a/com.unity.netcode.gameobjects/Runtime/SceneManagement/NetworkSceneHandle.cs b/com.unity.netcode.gameobjects/Runtime/SceneManagement/NetworkSceneHandle.cs
index e544eb1f24..f57414bcc5 100644
--- a/com.unity.netcode.gameobjects/Runtime/SceneManagement/NetworkSceneHandle.cs
+++ b/com.unity.netcode.gameobjects/Runtime/SceneManagement/NetworkSceneHandle.cs
@@ -34,7 +34,6 @@ public void NetworkSerialize(BufferSerializer serializer) where T : IReade
else
{
var reader = serializer.GetFastBufferReader();
- // DANGO-TODO Rust needs to be updated to either handle this ulong or to remove the scene store.
#if SCENE_MANAGEMENT_SCENE_HANDLE_MUST_USE_ULONG
reader.ReadValueSafe(out ulong rawData);
m_Handle = SceneHandle.FromRawData(rawData);
@@ -87,6 +86,11 @@ internal NetworkSceneHandle(int handle, bool asMock)
public int GetRawData() => m_Handle;
#endif
+ public override string ToString()
+ {
+ return m_Handle.ToString();
+ }
+
#region Implicit conversions
#if SCENE_MANAGEMENT_SCENE_HANDLE_AVAILABLE
///
diff --git a/com.unity.netcode.gameobjects/Runtime/SceneManagement/NetworkSceneManager.cs b/com.unity.netcode.gameobjects/Runtime/SceneManagement/NetworkSceneManager.cs
index 2fbdf1fbe9..c7ae07164f 100644
--- a/com.unity.netcode.gameobjects/Runtime/SceneManagement/NetworkSceneManager.cs
+++ b/com.unity.netcode.gameobjects/Runtime/SceneManagement/NetworkSceneManager.cs
@@ -5,6 +5,7 @@
using Unity.Collections;
using UnityEngine;
using UnityEngine.SceneManagement;
+using Debug = UnityEngine.Debug;
namespace Unity.Netcode
@@ -142,7 +143,7 @@ public class SceneEvent
///
/// Main class for managing network scenes when is enabled.
- /// Uses the message to communicate between the server and client(s)
+ /// Uses the SceneEventMessage message to communicate SceneEventData between the server and client(s)
///
[Serializable]
public class NetworkSceneManager : IDisposable
@@ -161,8 +162,7 @@ public class NetworkSceneManager : IDisposable
///
/// The delegate callback definition for scene event notifications.
/// See also:
- ///
- ///
+ ///
///
/// SceneEvent which contains information about the scene event, including type, progress, and scene details
public delegate void SceneEventDelegate(SceneEvent sceneEvent);
@@ -548,6 +548,15 @@ internal bool RemoveServerClientSceneHandle(NetworkSceneHandle serverHandle, Net
/// not destroy temporary scene are moved into the active scene
///
internal static bool IsSpawnedObjectsPendingInDontDestroyOnLoad;
+#if UNITY_EDITOR
+ [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+ private static void ResetStaticsOnLoad()
+ {
+ DisableReSynchronization = false;
+ IsSpawnedObjectsPendingInDontDestroyOnLoad = false;
+ SceneUnloadEventHandler.ResetInstances();
+ }
+#endif
///
/// Client and Server:
@@ -590,7 +599,7 @@ internal bool HasSceneAuthority()
}
///
- /// Handle NetworkSeneManager clean up
+ /// Handle NetworkSceneManager clean up
///
public void Dispose()
{
@@ -838,7 +847,7 @@ internal NetworkSceneManager(NetworkManager networkManager)
for (int i = 0; i < SceneManager.sceneCount; i++)
{
var loadedScene = SceneManager.GetSceneAt(i);
- ScenesLoaded.Add(loadedScene.handle, loadedScene);
+ UpdateServerClientSceneHandle(loadedScene.handle, loadedScene.handle, loadedScene);
}
SceneManagerHandler.PopulateLoadedScenes(ref ScenesLoaded, NetworkManager);
}
@@ -1025,7 +1034,7 @@ internal void SetTheSceneBeingSynchronized(NetworkSceneHandle serverSceneHandle)
// Most common scenario for DontDestroyOnLoad is when NetworkManager is set to not be destroyed
if (serverSceneHandle == DontDestroyOnLoadScene.handle)
{
- SceneBeingSynchronized = NetworkManager.gameObject.scene;
+ SceneBeingSynchronized = DontDestroyOnLoadScene;
return;
}
else
@@ -1570,6 +1579,9 @@ public SceneEventProgressStatus LoadScene(string sceneName, LoadSceneMode loadSc
internal class SceneUnloadEventHandler
{
private static Dictionary> s_Instances = new Dictionary>();
+#if UNITY_EDITOR
+ internal static void ResetInstances() => s_Instances = new Dictionary>();
+#endif
internal static void RegisterScene(NetworkSceneManager networkSceneManager, Scene scene, LoadSceneMode loadSceneMode, AsyncOperation asyncOperation = null)
{
@@ -1939,6 +1951,21 @@ private void OnClientLoadedScene(uint sceneEventId, Scene scene)
///
internal List ClientConnectionQueue = new List();
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ private void AddSceneToClientSynchronization(ref SceneEventData sceneEventData, ref Scene scene)
+ {
+ // If we are just a normal client and in distributed authority mode, then always use the known server scene handle
+ if (NetworkManager.DistributedAuthorityMode && NetworkManager.CMBServiceConnection)
+ {
+ sceneEventData.AddSceneToSynchronize(SceneHashFromNameOrPath(scene.path), ClientSceneHandleToServerSceneHandle[scene.handle]);
+ }
+ else
+ {
+ sceneEventData.AddSceneToSynchronize(SceneHashFromNameOrPath(scene.path), scene.handle);
+ }
+ }
+
///
/// Server Side:
/// This is used for players that have just had their connection approved and will assure they are synchronized
@@ -1989,61 +2016,53 @@ internal void SynchronizeNetworkObjects(ulong clientId, bool synchronizingServic
// Organize how (and when) we serialize our NetworkObjects
var hasSynchronizedActive = false;
- for (int i = 0; i < SceneManager.sceneCount; i++)
- {
- var scene = SceneManager.GetSceneAt(i);
- // NetworkSceneManager does not synchronize scenes that are not loaded by NetworkSceneManager
- // unless the scene in question is the currently active scene.
- if (ExcludeSceneFromSychronization != null && !ExcludeSceneFromSychronization(scene))
+ // It is possible a user might not want to synchronize the active scene, so we will check to see if it is valid before adding it to the synchronization list.
+ // !! Important !!
+ // The active scene MUST always be the first scene in the synchronization list.
+ if (ValidateSceneBeforeLoading(activeScene.buildIndex, activeScene.name, sceneEventData.LoadSceneMode))
+ {
+ sceneEventData.SceneHash = SceneHashFromNameOrPath(activeScene.path);
+ if (sceneEventData.SceneHash == sceneEventData.ActiveSceneHash)
{
- continue;
+ hasSynchronizedActive = true;
}
- if (scene == DontDestroyOnLoadScene)
+ // If we are just a normal client, then always use the server scene handle
+ if (NetworkManager.DistributedAuthorityMode)
{
- continue;
+ sceneEventData.SenderClientId = NetworkManager.LocalClientId;
+ sceneEventData.SceneHandle = ClientSceneHandleToServerSceneHandle[activeScene.handle];
}
-
- // This would depend upon whether we are additive or not
- // If we are the base scene, then we set the root scene index;
- if (activeScene == scene)
+ else
{
- if (!ValidateSceneBeforeLoading(scene.buildIndex, scene.name, sceneEventData.LoadSceneMode))
- {
- continue;
- }
- sceneEventData.SceneHash = SceneHashFromNameOrPath(scene.path);
- if (sceneEventData.SceneHash == sceneEventData.ActiveSceneHash)
- {
- hasSynchronizedActive = true;
- }
-
- // If we are just a normal client, then always use the server scene handle
- if (NetworkManager.DistributedAuthorityMode)
- {
- sceneEventData.SenderClientId = NetworkManager.LocalClientId;
- sceneEventData.SceneHandle = ClientSceneHandleToServerSceneHandle[scene.handle];
- }
- else
- {
- sceneEventData.SceneHandle = scene.handle;
- }
+ sceneEventData.SceneHandle = activeScene.handle;
}
- else if (!ValidateSceneBeforeLoading(scene.buildIndex, scene.name, LoadSceneMode.Additive))
+ AddSceneToClientSynchronization(ref sceneEventData, ref activeScene);
+ }
+
+ for (int i = 0; i < SceneManager.sceneCount; i++)
+ {
+ var scene = SceneManager.GetSceneAt(i);
+ // Skip adding the active scene at this point as we are just adding all other additively loaded scenes to the synchronization list.
+ // Skip adding the dont destroy on load scene as that is never synchronized.
+ if ((scene.handle == activeScene.handle) || (scene == DontDestroyOnLoadScene))
{
continue;
}
- // If we are just a normal client and in distributed authority mode, then always use the known server scene handle
- if (NetworkManager.DistributedAuthorityMode && NetworkManager.CMBServiceConnection)
+ // NetworkSceneManager does not synchronize scenes that are not loaded by NetworkSceneManager
+ // unless the scene in question is the currently active scene.
+ if (ExcludeSceneFromSychronization != null && !ExcludeSceneFromSychronization(scene))
{
- sceneEventData.AddSceneToSynchronize(SceneHashFromNameOrPath(scene.path), ClientSceneHandleToServerSceneHandle[scene.handle]);
+ continue;
}
- else
+
+ if (!ValidateSceneBeforeLoading(scene.buildIndex, scene.name, LoadSceneMode.Additive))
{
- sceneEventData.AddSceneToSynchronize(SceneHashFromNameOrPath(scene.path), scene.handle);
+ continue;
}
+ AddSceneToClientSynchronization(ref sceneEventData, ref scene);
}
if (!hasSynchronizedActive && NetworkManager.CMBServiceConnection && synchronizingService)
@@ -2096,9 +2115,12 @@ private void OnClientBeginSync(uint sceneEventId)
var sceneHash = sceneEventData.GetNextSceneSynchronizationHash();
var sceneHandle = sceneEventData.GetNextSceneSynchronizationHandle();
var sceneName = SceneNameFromHash(sceneHash);
+ var activeSceneName = SceneNameFromHash(sceneEventData.ActiveSceneHash);
var activeScene = SceneManager.GetActiveScene();
- var loadSceneMode = sceneHash == sceneEventData.SceneHash ? sceneEventData.LoadSceneMode : LoadSceneMode.Additive;
+ var activeSceneLoaded = activeSceneName == activeScene.name;
+
+ var loadSceneMode = sceneHash == sceneEventData.SceneHash && !activeSceneLoaded ? sceneEventData.LoadSceneMode : LoadSceneMode.Additive;
// Store the sceneHandle and hash
sceneEventData.NetworkSceneHandle = sceneHandle;
@@ -2234,12 +2256,10 @@ private void SynchronizeNetworkObjectScene()
// This is only done for dynamically spawned NetworkObjects
// Theoretically, a server could have NetworkObjects in a server-side only scene, if the client doesn't have that scene loaded
// then skip it (it will reside in the currently active scene in this scenario on the client-side)
- if (networkObject.IsSceneObject.Value == false && ServerSceneHandleToClientSceneHandle.ContainsKey(networkObject.NetworkSceneHandle))
+ if (!networkObject.InScenePlaced && ServerSceneHandleToClientSceneHandle.ContainsKey(networkObject.NetworkSceneHandle))
{
networkObject.SceneOriginHandle = ServerSceneHandleToClientSceneHandle[networkObject.NetworkSceneHandle];
-
-
// If the NetworkObject does not have a parent and is not in the same scene as it is on the server side, then find the right scene
// and move it to that scene.
if (networkObject.gameObject.scene.handle != networkObject.SceneOriginHandle && networkObject.transform.parent == null)
@@ -2247,11 +2267,6 @@ private void SynchronizeNetworkObjectScene()
if (ScenesLoaded.ContainsKey(networkObject.SceneOriginHandle))
{
var scene = ScenesLoaded[networkObject.SceneOriginHandle];
- if (scene == DontDestroyOnLoadScene)
- {
- Debug.Log($"{networkObject.gameObject.name} migrating into DDOL!");
- }
-
SceneManager.MoveGameObjectToScene(networkObject.gameObject, scene);
}
else if (NetworkManager.LogLevel <= LogLevel.Normal)
@@ -2709,7 +2724,7 @@ internal void MoveObjectsToDontDestroyOnLoad()
if (!networkObject.DestroyWithScene)
{
// Only move dynamically spawned NetworkObjects with no parent as the children will follow
- if (networkObject.gameObject.transform.parent == null && networkObject.IsSceneObject != null && !networkObject.IsSceneObject.Value)
+ if (networkObject.gameObject.transform.parent == null && !networkObject.InScenePlaced)
{
UnityEngine.Object.DontDestroyOnLoad(networkObject.gameObject);
// When temporarily migrating to the DDOL, adjust the network and origin scene handles so no messages are generated
@@ -2721,10 +2736,9 @@ internal void MoveObjectsToDontDestroyOnLoad()
else if (networkObject.HasAuthority)
{
networkObject.SetIsDestroying();
- var isSceneObject = networkObject.IsSceneObject;
// Only destroy non-scene placed NetworkObjects to avoid warnings about destroying in-scene placed NetworkObjects.
// (MoveObjectsToDontDestroyOnLoad is only invoked during a scene event type of load and the load scene mode is single)
- networkObject.Despawn(isSceneObject.HasValue && isSceneObject.Value == false);
+ networkObject.Despawn(!networkObject.InScenePlaced);
}
}
}
@@ -2745,19 +2759,27 @@ internal void PopulateScenePlacedObjects(Scene sceneToFilterBy, bool clearSceneP
{
ScenePlacedObjects.Clear();
}
- var networkObjects = FindObjects.ByType();
+ var sceneHandle = sceneToFilterBy.handle;
// Just add every NetworkObject found that isn't already in the list
// With additive scenes, we can have multiple in-scene placed NetworkObjects with the same GlobalObjectIdHash value
// During Client Side Synchronization: We add them on a FIFO basis, for each scene loaded without clearing, and then
// at the end of scene loading we use this list to soft synchronize all in-scene placed NetworkObjects
- foreach (var networkObjectInstance in networkObjects)
+ foreach (var networkObjectInstance in FindObjects.FromSceneByType(sceneToFilterBy, true))
{
+ if (!networkObjectInstance.InScenePlaced)
+ {
+ continue;
+ }
+
+ if (networkObjectInstance.NetworkManagerOwner == null)
+ {
+ networkObjectInstance.NetworkManagerOwner = NetworkManager;
+ }
+
var globalObjectIdHash = networkObjectInstance.GlobalObjectIdHash;
- var sceneHandle = networkObjectInstance.gameObject.scene.handle;
- // We check to make sure the NetworkManager instance is the same one to be "NetcodeIntegrationTestHelpers" compatible and filter the list on a per scene basis (for additive scenes)
- if (networkObjectInstance.IsSceneObject != false && (networkObjectInstance.NetworkManager == NetworkManager ||
- networkObjectInstance.NetworkManagerOwner == null) && sceneHandle == sceneToFilterBy.handle)
+ // We check to make sure the NetworkManager instance is the same one to be "NetcodeIntegrationTestHelpers" compatible and filter the list on a per-scene basis (for additive scenes)
+ if (networkObjectInstance.NetworkManagerOwner == NetworkManager && networkObjectInstance.isActiveAndEnabled)
{
if (!ScenePlacedObjects.ContainsKey(globalObjectIdHash))
{
@@ -2795,7 +2817,7 @@ internal void MoveObjectsFromDontDestroyOnLoadToScene(Scene scene)
{
// only move dynamically spawned network objects, with no parent as child objects will follow,
// back into the currently active scene
- if (networkObject.gameObject.transform.parent == null && networkObject.IsSceneObject != null && !networkObject.IsSceneObject.Value)
+ if (networkObject.gameObject.transform.parent == null && !networkObject.InScenePlaced)
{
if (NetworkManager.DistributedAuthorityMode)
{
@@ -2868,6 +2890,12 @@ internal bool IsSceneUnloading(NetworkObject networkObject)
///
internal void NotifyNetworkObjectSceneChanged(NetworkObject networkObject)
{
+ if (networkObject.NetworkManagerOwner != NetworkManager)
+ {
+ Debug.Log($"!!!!!!!!!!!!! Integration test is registering for scene migration for instances outside of the bounds of this NetworkManager context !!!!!!!!!!!!!");
+ return;
+ }
+
// Really, this should never happen but in case it does
if (!networkObject.HasAuthority)
{
@@ -2879,7 +2907,7 @@ internal void NotifyNetworkObjectSceneChanged(NetworkObject networkObject)
}
// Ignore in-scene placed NetworkObjects
- if (networkObject.IsSceneObject != false)
+ if (networkObject.InScenePlaced)
{
// Really, this should ever happen but in case it does
if (NetworkManager.LogLevel == LogLevel.Developer)
@@ -2891,7 +2919,7 @@ internal void NotifyNetworkObjectSceneChanged(NetworkObject networkObject)
// Ignore if the scene is the currently active scene and the NetworkObject is auto synchronizing/migrating
// to the currently active scene.
- if (networkObject.gameObject.scene == SceneManager.GetActiveScene() && networkObject.ActiveSceneSynchronization)
+ if (networkObject.gameObject.scene.name == SceneManager.GetActiveScene().name && networkObject.ActiveSceneSynchronization)
{
return;
}
@@ -2900,6 +2928,13 @@ internal void NotifyNetworkObjectSceneChanged(NetworkObject networkObject)
// Note: This does not apply to SceneEventType.Synchronize since synchronization isn't a global connected client event.
if (IsSceneEventInProgress())
{
+ Debug.Log($"{networkObject.name} scene event in progress -- ignoring!");
+ return;
+ }
+
+ if (IsSceneUnloading(networkObject))
+ {
+ Debug.Log($"{networkObject.name} scene unloading in progress -- ignoring!");
return;
}
@@ -3024,7 +3059,15 @@ internal void CheckForAndSendNetworkObjectSceneChanged()
// Some NetworkObjects still exist, send the message
var sceneEvent = BeginSceneEvent();
sceneEvent.SceneEventType = SceneEventType.ObjectSceneChanged;
- SendSceneEventData(sceneEvent.SceneEventId, NetworkManager.ConnectedClientsIds.Where(c => c != NetworkManager.LocalClientId).ToArray());
+ // SendSceneEventData can throw an exception. We need to wrap this and recover from the exception gracefully.
+ try
+ {
+ SendSceneEventData(sceneEvent.SceneEventId, NetworkManager.ConnectedClientsIds.Where(c => c != NetworkManager.LocalClientId).ToArray());
+ }
+ catch (Exception ex)
+ {
+ Debug.LogException(ex);
+ }
ObjectsMigratedIntoNewScene.Clear();
EndSceneEvent(sceneEvent.SceneEventId);
}
diff --git a/com.unity.netcode.gameobjects/Runtime/SceneManagement/SceneEventData.cs b/com.unity.netcode.gameobjects/Runtime/SceneManagement/SceneEventData.cs
index 0fff313574..6195fa2335 100644
--- a/com.unity.netcode.gameobjects/Runtime/SceneManagement/SceneEventData.cs
+++ b/com.unity.netcode.gameobjects/Runtime/SceneManagement/SceneEventData.cs
@@ -130,22 +130,21 @@ internal class SceneEventData : IDisposable
/// was synchronizing (if so server will send another message back to the client informing the client of NetworkObjects to remove)
/// spawned during an initial synchronization.
///
- private List m_NetworkObjectsSync = new List();
+ private readonly List m_NetworkObjectsSync = new List();
- private List m_DespawnedInSceneObjectsSync = new List();
- private Dictionary> m_DespawnedInSceneObjects = new Dictionary>();
+ private readonly List m_DespawnedInSceneObjectsSync = new List();
///
/// Server Side Re-Synchronization:
/// If there happens to be NetworkObjects in the final Event_Sync_Complete message that are no longer spawned,
/// the server will compile a list and send back an Event_ReSync message to the client.
///
- private List m_NetworkObjectsToBeRemoved = new List();
+ private readonly List m_NetworkObjectsToBeRemoved = new List();
private bool m_HasInternalBuffer;
- internal FastBufferReader InternalBuffer;
+ private FastBufferReader m_InternalBuffer;
- private NetworkManager m_NetworkManager;
+ private readonly NetworkManager m_NetworkManager;
internal List ClientsCompleted;
internal List ClientsTimedOut;
@@ -165,10 +164,10 @@ internal class SceneEventData : IDisposable
/// we must distinguish which scene we are talking about when the server tells the client to unload a scene.
/// The server will always communicate its local relative scene's handle and the client will determine its
/// local relative handle from the table being built.
- /// Look for usage to see where
+ /// Look for usage to see where
/// entries are being added to or removed from the table
///
- ///
+ ///
///
internal void AddSceneToSynchronize(uint sceneHash, NetworkSceneHandle sceneHandle)
{
@@ -316,8 +315,6 @@ private void SortParentedNetworkObjects()
}
}
- internal static bool LogSerializationOrder = false;
-
internal void AddSpawnedNetworkObjects()
{
m_NetworkObjectsSync.Clear();
@@ -353,7 +350,7 @@ private void SortObjectsToSync()
// This is useful to know what NetworkObjects a client is going to be synchronized with
// as well as the order in which they will be deserialized
- if (LogSerializationOrder && m_NetworkManager.LogLevel == LogLevel.Developer)
+ if (NetworkLog.Config.LogSerializationOrder && m_NetworkManager.LogLevel == LogLevel.Developer)
{
var messageBuilder = new StringBuilder(0xFFFF);
messageBuilder.AppendLine("[Server-Side Client-Synchronization] NetworkObject serialization order:");
@@ -369,13 +366,19 @@ internal void AddDespawnedInSceneNetworkObjects()
{
m_DespawnedInSceneObjectsSync.Clear();
// Find all active and non-active in-scene placed NetworkObjects
- var inSceneNetworkObjects = FindObjects.ByType(true, true).Where((c) => c.NetworkManager == m_NetworkManager);
- foreach (var sobj in inSceneNetworkObjects)
+ foreach (var scene in m_NetworkManager.SceneManager.ScenesLoaded.Values)
{
- if (sobj.IsSceneObject.HasValue && sobj.IsSceneObject.Value && !sobj.IsSpawned)
+ // Ignore invalid scenes
+ if (!scene.IsValid())
{
- sobj.NetworkManagerOwner = m_NetworkManager;
- m_DespawnedInSceneObjectsSync.Add(sobj);
+ continue;
+ }
+ foreach (var networkObject in FindObjects.FromSceneByType(scene, true))
+ {
+ if (networkObject.InScenePlaced && networkObject.NetworkManagerOwner == m_NetworkManager && !networkObject.IsSpawned)
+ {
+ m_DespawnedInSceneObjectsSync.Add(networkObject);
+ }
}
}
}
@@ -388,12 +391,12 @@ internal void AddDespawnedInSceneNetworkObjects()
///
internal void AddNetworkObjectForSynch(uint sceneIndex, NetworkObject networkObject)
{
- if (!m_SceneNetworkObjects.ContainsKey(sceneIndex))
+ if (!m_SceneNetworkObjects.TryGetValue(sceneIndex, out var sceneNetworkObject))
{
- m_SceneNetworkObjects.Add(sceneIndex, new List());
+ sceneNetworkObject = new List();
+ m_SceneNetworkObjects.Add(sceneIndex, sceneNetworkObject);
}
-
- m_SceneNetworkObjects[sceneIndex].Add(networkObject);
+ sceneNetworkObject.Add(networkObject);
}
///
@@ -568,7 +571,7 @@ internal void Serialize(FastBufferWriter writer)
private unsafe void CopyInternalBuffer(ref FastBufferWriter writer)
{
- writer.WriteBytesSafe(InternalBuffer.GetUnsafePtrAtCurrentPosition(), InternalBuffer.Length);
+ writer.WriteBytesSafe(m_InternalBuffer.GetUnsafePtrAtCurrentPosition(), m_InternalBuffer.Length);
}
///
@@ -576,9 +579,9 @@ private unsafe void CopyInternalBuffer(ref FastBufferWriter writer)
/// Called at the end of a event once the scene is loaded and scene placed NetworkObjects
/// have been locally spawned
///
- internal void WriteSceneSynchronizationData(FastBufferWriter writer)
+ private void WriteSceneSynchronizationData(FastBufferWriter writer)
{
- var builder = (StringBuilder)null;
+ StringBuilder builder = null;
if (EnableSerializationLogs)
{
builder = new StringBuilder();
@@ -601,11 +604,10 @@ internal void WriteSceneSynchronizationData(FastBufferWriter writer)
return;
}
- // Size Place Holder -- Start
+ // Size Placeholder -- Start
// !!NOTE!!: Since this is a placeholder to be set after we know how much we have written,
// for stream offset purposes this MUST not be a packed value!
writer.WriteValueSafe(0);
- int totalBytes = 0;
// Write the number of NetworkObjects we are serializing
writer.WriteValueSafe(m_NetworkObjectsSync.Count);
@@ -616,16 +618,14 @@ internal void WriteSceneSynchronizationData(FastBufferWriter writer)
var distributedAuthority = m_NetworkManager.DistributedAuthorityMode;
// Serialize all NetworkObjects that are spawned
- for (var i = 0; i < m_NetworkObjectsSync.Count; ++i)
+ foreach (var networkObject in m_NetworkObjectsSync)
{
- var networkObject = m_NetworkObjectsSync[i];
var noStart = writer.Position;
// In distributed authority mode, we send the currently known observers of each NetworkObject to the client being synchronized.
- var serializedObject = m_NetworkObjectsSync[i].Serialize(TargetClientId, distributedAuthority);
+ var serializedObject = networkObject.SerializeSpawnedObject(TargetClientId, distributedAuthority);
serializedObject.Serialize(writer);
var noStop = writer.Position;
- totalBytes += noStop - noStart;
if (EnableSerializationLogs)
{
var offStart = noStart - (positionStart + sizeof(int));
@@ -642,16 +642,13 @@ internal void WriteSceneSynchronizationData(FastBufferWriter writer)
// Write the number of despawned in-scene placed NetworkObjects
writer.WriteValueSafe(m_DespawnedInSceneObjectsSync.Count);
// Write the scene handle and GlobalObjectIdHash value
- for (var i = 0; i < m_DespawnedInSceneObjectsSync.Count; ++i)
+ foreach (var despawnedInSceneObject in m_DespawnedInSceneObjectsSync)
{
- var noStart = writer.Position;
- writer.WriteValueSafe(m_DespawnedInSceneObjectsSync[i].GetSceneOriginHandle());
- writer.WriteValueSafe(m_DespawnedInSceneObjectsSync[i].GlobalObjectIdHash);
- var noStop = writer.Position;
- totalBytes += noStop - noStart;
+ writer.WriteValueSafe(despawnedInSceneObject.GetSceneOriginHandle());
+ writer.WriteValueSafe(despawnedInSceneObject.GlobalObjectIdHash);
}
- // Size Place Holder -- End
+ // Size Placeholder -- End
var positionEnd = writer.Position;
var bytesWritten = (uint)(positionEnd - (positionStart + sizeof(uint)));
writer.Seek(positionStart);
@@ -670,12 +667,12 @@ internal void WriteSceneSynchronizationData(FastBufferWriter writer)
/// have been locally spawned
/// Maximum number of objects that could theoretically be synchronized is 65536
///
- internal void SerializeScenePlacedObjects(FastBufferWriter writer)
+ private void SerializeScenePlacedObjects(FastBufferWriter writer)
{
- var numberOfObjects = (ushort)0;
+ ushort numberOfObjects = 0;
var headPosition = writer.Position;
- // Write our count place holder (must not be packed!)
+ // Write our count placeholder (must not be packed!)
writer.WriteValueSafe((ushort)0);
var distributedAuthority = m_NetworkManager.DistributedAuthorityMode;
// If distributed authority mode and sending to the service, then ignore observers
@@ -698,10 +695,10 @@ internal void SerializeScenePlacedObjects(FastBufferWriter writer)
SortObjectsToSync();
// Serialize the sorted objects to sync.
- foreach (var objectToSycn in m_NetworkObjectsSync)
+ foreach (var objectToSync in m_NetworkObjectsSync)
{
// Serialize the NetworkObject
- var serializedObject = objectToSycn.Serialize(TargetClientId, distributedAuthority);
+ var serializedObject = objectToSync.SerializeSpawnedObject(TargetClientId, distributedAuthority);
serializedObject.Serialize(writer);
numberOfObjects++;
}
@@ -709,10 +706,10 @@ internal void SerializeScenePlacedObjects(FastBufferWriter writer)
// Write the number of despawned in-scene placed NetworkObjects
writer.WriteValueSafe(m_DespawnedInSceneObjectsSync.Count);
// Write the scene handle and GlobalObjectIdHash value
- for (var i = 0; i < m_DespawnedInSceneObjectsSync.Count; ++i)
+ foreach (var despawnedInSceneObject in m_DespawnedInSceneObjectsSync)
{
- writer.WriteValueSafe(m_DespawnedInSceneObjectsSync[i].GetSceneOriginHandle());
- writer.WriteValueSafe(m_DespawnedInSceneObjectsSync[i].GlobalObjectIdHash);
+ writer.WriteValueSafe(despawnedInSceneObject.GetSceneOriginHandle());
+ writer.WriteValueSafe(despawnedInSceneObject.GlobalObjectIdHash);
}
var tailPosition = writer.Position;
@@ -799,7 +796,7 @@ internal void Deserialize(FastBufferReader reader)
// be processed once we are done loading.
m_HasInternalBuffer = true;
// We use Allocator.Persistent since scene loading could take longer than 4 frames
- InternalBuffer = new FastBufferReader(reader.GetUnsafePtrAtCurrentPosition(), Allocator.Persistent, reader.Length - reader.Position);
+ m_InternalBuffer = new FastBufferReader(reader.GetUnsafePtrAtCurrentPosition(), Allocator.Persistent, reader.Length - reader.Position);
}
break;
}
@@ -825,7 +822,7 @@ internal void Deserialize(FastBufferReader reader)
/// into the internal buffer to be used throughout the synchronization process.
///
///
- internal void CopySceneSynchronizationData(FastBufferReader reader)
+ private void CopySceneSynchronizationData(FastBufferReader reader)
{
m_NetworkObjectsSync.Clear();
reader.ReadValueSafe(out uint[] scenesToSynchronize);
@@ -847,10 +844,10 @@ internal void CopySceneSynchronizationData(FastBufferReader reader)
m_HasInternalBuffer = true;
// We use Allocator.Persistent since scene synchronization will most likely take longer than 4 frames
- InternalBuffer = new FastBufferReader(reader.GetUnsafePtrAtCurrentPosition(), Allocator.Persistent, sizeToCopy);
+ m_InternalBuffer = new FastBufferReader(reader.GetUnsafePtrAtCurrentPosition(), Allocator.Persistent, sizeToCopy);
if (EnableSerializationLogs)
{
- LogArray(InternalBuffer.ToArray());
+ LogArray(m_InternalBuffer.ToArray());
}
}
}
@@ -865,12 +862,12 @@ internal void DeserializeScenePlacedObjects()
try
{
// is not packed!
- InternalBuffer.ReadValueSafe(out ushort newObjectsCount);
+ m_InternalBuffer.ReadValueSafe(out ushort newObjectsCount);
var sceneObjects = new List();
for (ushort i = 0; i < newObjectsCount; i++)
{
var serializedObject = new NetworkObject.SerializedObject();
- serializedObject.Deserialize(InternalBuffer);
+ serializedObject.Deserialize(m_InternalBuffer);
if (serializedObject.IsSceneObject)
{
@@ -878,9 +875,9 @@ internal void DeserializeScenePlacedObjects()
m_NetworkManager.SceneManager.SetTheSceneBeingSynchronized(serializedObject.NetworkSceneHandle);
}
- var networkObject = NetworkObject.Deserialize(serializedObject, InternalBuffer, m_NetworkManager);
+ var networkObject = NetworkObject.DeserializeAndSpawnObject(serializedObject, m_InternalBuffer, m_NetworkManager);
- if (serializedObject.IsSceneObject)
+ if (serializedObject.IsSceneObject && networkObject != null)
{
sceneObjects.Add(networkObject);
}
@@ -897,7 +894,7 @@ internal void DeserializeScenePlacedObjects()
}
finally
{
- InternalBuffer.Dispose();
+ m_InternalBuffer.Dispose();
m_HasInternalBuffer = false;
}
}
@@ -909,7 +906,7 @@ internal void DeserializeScenePlacedObjects()
/// client handles any returned values by the server.
///
///
- internal void ReadClientReSynchronizationData(FastBufferReader reader)
+ private void ReadClientReSynchronizationData(FastBufferReader reader)
{
reader.ReadValueSafe(out uint[] networkObjectsToRemove);
@@ -946,7 +943,7 @@ internal void ReadClientReSynchronizationData(FastBufferReader reader)
/// the server will compile a list and send back an Event_ReSync message to the client.
///
///
- internal void WriteClientReSynchronizationData(FastBufferWriter writer)
+ private void WriteClientReSynchronizationData(FastBufferWriter writer)
{
//Write how many objects need to be removed
writer.WriteValueSafe(m_NetworkObjectsToBeRemoved.ToArray());
@@ -960,7 +957,7 @@ internal void WriteClientReSynchronizationData(FastBufferWriter writer)
///
internal bool ClientNeedsReSynchronization()
{
- return (m_NetworkObjectsToBeRemoved.Count > 0);
+ return m_NetworkObjectsToBeRemoved.Count > 0;
}
///
@@ -970,7 +967,7 @@ internal bool ClientNeedsReSynchronization()
/// have since been despawned.
///
///
- internal void CheckClientSynchronizationResults(FastBufferReader reader)
+ private void CheckClientSynchronizationResults(FastBufferReader reader)
{
m_NetworkObjectsToBeRemoved.Clear();
reader.ReadValueSafe(out uint networkObjectIdCount);
@@ -987,12 +984,12 @@ internal void CheckClientSynchronizationResults(FastBufferReader reader)
///
/// Client Side:
/// During the deserialization process of the servers Event_Sync, the client builds a list of
- /// all NetworkObjectIds that were spawned. Upon responding to the server with the Event_Sync_Complete
+ /// all NetworkObjectIds that were spawned. Upon responding to the server with the Event_Sync_Complete,
/// this list is included for the server to review over and determine if the client needs a minor resynchronization
/// of NetworkObjects that might have been despawned while the client was processing the Event_Sync.
///
///
- internal void WriteClientSynchronizationResults(FastBufferWriter writer)
+ private void WriteClientSynchronizationResults(FastBufferWriter writer)
{
//Write how many objects were spawned
writer.WriteValueSafe((uint)m_NetworkObjectsSync.Count);
@@ -1009,34 +1006,29 @@ internal void WriteClientSynchronizationResults(FastBufferWriter writer)
private void DeserializeDespawnedInScenePlacedNetworkObjects()
{
// Process all de-spawned in-scene NetworkObjects for this network session
- m_DespawnedInSceneObjects.Clear();
- InternalBuffer.ReadValueSafe(out int despawnedObjectsCount);
+ m_InternalBuffer.ReadValueSafe(out int despawnedObjectsCount);
var sceneCache = new Dictionary>();
for (int i = 0; i < despawnedObjectsCount; i++)
{
// We just need to get the scene
- InternalBuffer.ReadValueSafe(out NetworkSceneHandle networkSceneHandle);
- InternalBuffer.ReadValueSafe(out uint globalObjectIdHash);
- var sceneRelativeNetworkObjects = new Dictionary();
- if (!sceneCache.ContainsKey(networkSceneHandle))
+ m_InternalBuffer.ReadValueSafe(out NetworkSceneHandle networkSceneHandle);
+ m_InternalBuffer.ReadValueSafe(out uint globalObjectIdHash);
+
+ // Check if we already have processed the objects in this scene
+ if (!sceneCache.TryGetValue(networkSceneHandle, out var sceneRelativeNetworkObjects))
{
- if (m_NetworkManager.SceneManager.ServerSceneHandleToClientSceneHandle.ContainsKey(networkSceneHandle))
+ // If we haven't already cached the objects in this scene, build the cache
+ sceneRelativeNetworkObjects = new Dictionary();
+ if (m_NetworkManager.SceneManager.ServerSceneHandleToClientSceneHandle.TryGetValue(networkSceneHandle, out var localSceneHandle))
{
- var localSceneHandle = m_NetworkManager.SceneManager.ServerSceneHandleToClientSceneHandle[networkSceneHandle];
- if (m_NetworkManager.SceneManager.ScenesLoaded.ContainsKey(localSceneHandle))
+ if (m_NetworkManager.SceneManager.ScenesLoaded.TryGetValue(localSceneHandle, out var objectRelativeScene))
{
- var objectRelativeScene = m_NetworkManager.SceneManager.ScenesLoaded[localSceneHandle];
-
- // Find all active and non-active in-scene placed NetworkObjects
- var inSceneNetworkObjects = FindObjects.ByType(true, true).Where((c) =>
- c.GetSceneOriginHandle() == localSceneHandle && (c.IsSceneObject != false)).ToList();
-
- foreach (var inSceneObject in inSceneNetworkObjects)
+ foreach (var networkObject in FindObjects.FromSceneByType(objectRelativeScene, true))
{
- if (!sceneRelativeNetworkObjects.ContainsKey(inSceneObject.GlobalObjectIdHash))
+ if (networkObject.InScenePlaced)
{
- sceneRelativeNetworkObjects.Add(inSceneObject.GlobalObjectIdHash, inSceneObject);
+ sceneRelativeNetworkObjects.TryAdd(networkObject.GlobalObjectIdHash, networkObject);
}
}
// Add this to a cache so we don't have to run this potentially multiple times (nothing will spawn or despawn during this time
@@ -1052,10 +1044,6 @@ private void DeserializeDespawnedInScenePlacedNetworkObjects()
UnityEngine.Debug.LogError($"In-Scene NetworkObject GlobalObjectIdHash ({globalObjectIdHash}) cannot find its relative NetworkSceneHandle {networkSceneHandle}!");
}
}
- else // Use the cached NetworkObjects if they exist
- {
- sceneRelativeNetworkObjects = sceneCache[networkSceneHandle];
- }
// Now find the in-scene NetworkObject with the current GlobalObjectIdHash we are looking for
if (sceneRelativeNetworkObjects.TryGetValue(globalObjectIdHash, out var despawnedObject))
@@ -1066,15 +1054,10 @@ private void DeserializeDespawnedInScenePlacedNetworkObjects()
// Since this is a NetworkObject that was never spawned, we just need to send a notification
// out that it was despawned so users can make adjustments
despawnedObject.InvokeBehaviourNetworkDespawn();
- if (!m_NetworkManager.SceneManager.ScenePlacedObjects.ContainsKey(globalObjectIdHash))
- {
- m_NetworkManager.SceneManager.ScenePlacedObjects.Add(globalObjectIdHash, new Dictionary());
- }
- if (!m_NetworkManager.SceneManager.ScenePlacedObjects[globalObjectIdHash].ContainsKey(despawnedObject.GetSceneOriginHandle()))
- {
- m_NetworkManager.SceneManager.ScenePlacedObjects[globalObjectIdHash].Add(despawnedObject.GetSceneOriginHandle(), despawnedObject);
- }
+ m_NetworkManager.SceneManager.ScenePlacedObjects.TryAdd(globalObjectIdHash, new Dictionary());
+
+ m_NetworkManager.SceneManager.ScenePlacedObjects[globalObjectIdHash].TryAdd(despawnedObject.GetSceneOriginHandle(), despawnedObject);
}
else
{
@@ -1092,7 +1075,7 @@ private void DeserializeDespawnedInScenePlacedNetworkObjects()
///
internal void SynchronizeSceneNetworkObjects(NetworkManager networkManager)
{
- var builder = (StringBuilder)null;
+ StringBuilder builder = null;
if (EnableSerializationLogs)
{
builder = new StringBuilder();
@@ -1101,38 +1084,39 @@ internal void SynchronizeSceneNetworkObjects(NetworkManager networkManager)
try
{
// Process all spawned NetworkObjects for this network session
- InternalBuffer.ReadValueSafe(out int newObjectsCount);
+ m_InternalBuffer.ReadValueSafe(out int newObjectsCount);
if (EnableSerializationLogs)
{
- builder.AppendLine($"[Read][Synchronize Objects][WPos: {InternalBuffer.Position}][NO-Count: {newObjectsCount}] Begin:");
+ builder.AppendLine($"[Read][Synchronize Objects][WPos: {m_InternalBuffer.Position}][NO-Count: {newObjectsCount}] Begin:");
}
for (int i = 0; i < newObjectsCount; i++)
{
- var noStart = InternalBuffer.Position;
+ var noStart = m_InternalBuffer.Position;
var serializedObject = new NetworkObject.SerializedObject();
- serializedObject.Deserialize(InternalBuffer);
+ serializedObject.Deserialize(m_InternalBuffer);
// If the sceneObject is in-scene placed, then set the scene being synchronized
if (serializedObject.IsSceneObject)
{
m_NetworkManager.SceneManager.SetTheSceneBeingSynchronized(serializedObject.NetworkSceneHandle);
}
- var spawnedNetworkObject = NetworkObject.Deserialize(serializedObject, InternalBuffer, networkManager);
+ var spawnedNetworkObject = NetworkObject.DeserializeAndSpawnObject(serializedObject, m_InternalBuffer, networkManager);
+ if (spawnedNetworkObject == null)
+ {
+ continue;
+ }
- var noStop = InternalBuffer.Position;
+ var noStop = m_InternalBuffer.Position;
if (EnableSerializationLogs)
{
builder.AppendLine($"[Head: {noStart}][Tail: {noStop}][Size: {noStop - noStart}][{spawnedNetworkObject.name}][NID-{spawnedNetworkObject.NetworkObjectId}][Children: {spawnedNetworkObject.ChildNetworkBehaviours.Count}]");
- LogArray(InternalBuffer.ToArray(), noStart, noStop, builder);
+ LogArray(m_InternalBuffer.ToArray(), noStart, noStop, builder);
}
- // If we failed to deserialize the NetowrkObject then don't add null to the list
- if (spawnedNetworkObject != null)
+ // If we failed to deserialize the NetworkObject then don't add null to the list
+ if (!m_NetworkObjectsSync.Contains(spawnedNetworkObject))
{
- if (!m_NetworkObjectsSync.Contains(spawnedNetworkObject))
- {
- m_NetworkObjectsSync.Add(spawnedNetworkObject);
- }
+ m_NetworkObjectsSync.Add(spawnedNetworkObject);
}
}
if (EnableSerializationLogs)
@@ -1143,7 +1127,7 @@ internal void SynchronizeSceneNetworkObjects(NetworkManager networkManager)
// Notify that all in-scene placed NetworkObjects have been spawned
foreach (var networkObject in m_NetworkObjectsSync)
{
- if (networkObject.IsSceneObject.HasValue && networkObject.IsSceneObject.Value)
+ if (networkObject.IsSpawned && networkObject.InScenePlaced)
{
networkObject.InternalInSceneNetworkObjectsSpawned();
}
@@ -1156,11 +1140,14 @@ internal void SynchronizeSceneNetworkObjects(NetworkManager networkManager)
catch (Exception ex)
{
UnityEngine.Debug.LogException(ex);
- UnityEngine.Debug.Log(builder.ToString());
+ if (EnableSerializationLogs)
+ {
+ UnityEngine.Debug.Log(builder.ToString());
+ }
}
finally
{
- InternalBuffer.Dispose();
+ m_InternalBuffer.Dispose();
m_HasInternalBuffer = false;
}
}
@@ -1169,7 +1156,7 @@ internal void SynchronizeSceneNetworkObjects(NetworkManager networkManager)
/// Writes the all clients loaded or unloaded completed and timed out lists
///
///
- internal void WriteSceneEventProgressDone(FastBufferWriter writer)
+ private void WriteSceneEventProgressDone(FastBufferWriter writer)
{
writer.WriteValueSafe((ushort)ClientsCompleted.Count);
foreach (var clientId in ClientsCompleted)
@@ -1188,7 +1175,7 @@ internal void WriteSceneEventProgressDone(FastBufferWriter writer)
/// Reads the all clients loaded or unloaded completed and timed out lists
///
///
- internal void ReadSceneEventProgressDone(FastBufferReader reader)
+ private void ReadSceneEventProgressDone(FastBufferReader reader)
{
reader.ReadValueSafe(out ushort completedCount);
ClientsCompleted = new List();
@@ -1217,31 +1204,51 @@ internal void ReadSceneEventProgressDone(FastBufferReader reader)
private void SerializeObjectsMovedIntoNewScene(FastBufferWriter writer)
{
var sceneManager = m_NetworkManager.SceneManager;
- var ownerId = m_NetworkManager.LocalClientId;
+ var networkManagerClientId = m_NetworkManager.LocalClientId;
if (IsForwarding)
{
- ownerId = m_OwnerId;
+ networkManagerClientId = m_OwnerId;
}
// Write the owner identifier
- writer.WriteValueSafe(ownerId);
+ writer.WriteValueSafe(networkManagerClientId);
- // Write the number of scene handles
- writer.WriteValueSafe(sceneManager.ObjectsMigratedIntoNewScene.Count);
+ // Create a place holder for the number of entries written.
+ // Distributed authority this could end up being just a single entry for
+ // one of several scenes loaded. As such, we need to count how many entries
+ // are actually written.
+ var countPosition = writer.Position;
+ writer.WriteValueSafe(0);
+ var entriesWritten = 0;
foreach (var sceneHandleObjects in sceneManager.ObjectsMigratedIntoNewScene)
{
- if (!sceneManager.ObjectsMigratedIntoNewScene[sceneHandleObjects.Key].ContainsKey(ownerId))
+ // Since these are separated by scene then owner, there could be scenes that have
+ // no changes.
+ if (!sceneHandleObjects.Value.ContainsKey(networkManagerClientId))
{
- throw new Exception($"Trying to send object scene migration for Client-{ownerId} but the client has no entries to send!");
+ continue;
}
// Write the scene handle
writer.WriteValueSafe(sceneHandleObjects.Key);
// Write the number of NetworkObjectIds to expect
- writer.WriteValueSafe(sceneHandleObjects.Value[ownerId].Count);
- foreach (var networkObject in sceneHandleObjects.Value[ownerId])
+ writer.WriteValueSafe(sceneHandleObjects.Value[networkManagerClientId].Count);
+ foreach (var networkObject in sceneHandleObjects.Value[networkManagerClientId])
{
writer.WriteValueSafe(networkObject.NetworkObjectId);
}
+ entriesWritten++;
+ }
+ if (entriesWritten == 0)
+ {
+ throw new Exception($"Trying to send object scene migration for Client-{networkManagerClientId} but the client has no entries to send!");
+ }
+ else
+ {
+ // Write the number of entries written
+ var endPosition = writer.Position;
+ writer.Seek(countPosition);
+ writer.WriteValueSafe(entriesWritten);
+ writer.Seek(endPosition);
}
}
@@ -1254,40 +1261,31 @@ private void DeserializeObjectsMovedIntoNewScene(FastBufferReader reader)
var sceneManager = m_NetworkManager.SceneManager;
var spawnManager = m_NetworkManager.SpawnManager;
- var numberOfScenes = 0;
- NetworkSceneHandle sceneHandle;
- var objectCount = 0;
- var networkObjectId = (ulong)0;
-
- var ownerID = (ulong)0;
- reader.ReadValueSafe(out ownerID);
+ reader.ReadValueSafe(out ulong ownerID);
m_OwnerId = ownerID;
- reader.ReadValueSafe(out numberOfScenes);
+ reader.ReadValueSafe(out int numberOfScenes);
for (int i = 0; i < numberOfScenes; i++)
{
- reader.ReadValueSafe(out sceneHandle);
+ reader.ReadValueSafe(out NetworkSceneHandle sceneHandle);
if (!sceneManager.ObjectsMigratedIntoNewScene.TryGetValue(sceneHandle, out var migratedObjects))
{
migratedObjects = new Dictionary>();
sceneManager.ObjectsMigratedIntoNewScene.Add(sceneHandle, migratedObjects);
}
- if (!migratedObjects.ContainsKey(ownerID))
- {
- migratedObjects.Add(ownerID, new List());
- }
+ migratedObjects.TryAdd(ownerID, new List());
- reader.ReadValueSafe(out objectCount);
+ reader.ReadValueSafe(out int objectCount);
for (int j = 0; j < objectCount; j++)
{
- reader.ReadValueSafe(out networkObjectId);
- if (!spawnManager.SpawnedObjects.ContainsKey(networkObjectId))
+ reader.ReadValueSafe(out ulong networkObjectId);
+ if (!spawnManager.SpawnedObjects.TryGetValue(networkObjectId, out var networkObject))
{
NetworkLog.LogError($"[Object Scene Migration] Trying to synchronize NetworkObjectId ({networkObjectId}) but it was not spawned or no longer exists!!");
continue;
}
- var networkObject = spawnManager.SpawnedObjects[networkObjectId];
+
// Add NetworkObject scene migration to ObjectsMigratedIntoNewScene dictionary that is processed
migratedObjects[ownerID].Add(networkObject);
}
@@ -1304,15 +1302,8 @@ private void DeserializeObjectsMovedIntoNewScene(FastBufferReader reader)
private void DeferObjectsMovedIntoNewScene(FastBufferReader reader)
{
var sceneManager = m_NetworkManager.SceneManager;
- var spawnManager = m_NetworkManager.SpawnManager;
- var ownerId = (ulong)0;
- var numberOfScenes = 0;
- NetworkSceneHandle sceneHandle;
- var objectCount = 0;
- var networkObjectId = (ulong)0;
-
- reader.ReadValueSafe(out ownerId);
+ reader.ReadValueSafe(out ulong ownerId);
var deferredObjectsMovedEvent = new NetworkSceneManager.DeferredObjectsMovedEvent()
{
@@ -1320,17 +1311,16 @@ private void DeferObjectsMovedIntoNewScene(FastBufferReader reader)
ObjectsMigratedTable = new Dictionary>(),
};
-
- reader.ReadValueSafe(out numberOfScenes);
+ reader.ReadValueSafe(out int numberOfScenes);
for (int i = 0; i < numberOfScenes; i++)
{
- reader.ReadValueSafe(out sceneHandle);
+ reader.ReadValueSafe(out NetworkSceneHandle sceneHandle);
var objectsMigrated = new List();
deferredObjectsMovedEvent.ObjectsMigratedTable.Add(sceneHandle, objectsMigrated);
- reader.ReadValueSafe(out objectCount);
+ reader.ReadValueSafe(out int objectCount);
for (int j = 0; j < objectCount; j++)
{
- reader.ReadValueSafe(out networkObjectId);
+ reader.ReadValueSafe(out ulong networkObjectId);
objectsMigrated.Add(networkObjectId);
}
}
@@ -1354,10 +1344,9 @@ internal void ProcessDeferredObjectSceneChangedEvents()
migratedObjects = new Dictionary>();
sceneManager.ObjectsMigratedIntoNewScene.Add(keyEntry.Key, migratedObjects);
}
- if (!migratedObjects.ContainsKey(objectsMovedEvent.OwnerId))
- {
- migratedObjects.Add(objectsMovedEvent.OwnerId, new List());
- }
+
+ migratedObjects.TryAdd(objectsMovedEvent.OwnerId, new List());
+ var objectList = migratedObjects[objectsMovedEvent.OwnerId];
foreach (var objectId in keyEntry.Value)
{
@@ -1367,9 +1356,9 @@ internal void ProcessDeferredObjectSceneChangedEvents()
continue;
}
- if (!migratedObjects[objectsMovedEvent.OwnerId].Contains(networkObject))
+ if (!objectList.Contains(networkObject))
{
- migratedObjects[objectsMovedEvent.OwnerId].Add(networkObject);
+ objectList.Add(networkObject);
}
}
}
@@ -1385,7 +1374,7 @@ public void Dispose()
{
if (m_HasInternalBuffer)
{
- InternalBuffer.Dispose();
+ m_InternalBuffer.Dispose();
m_HasInternalBuffer = false;
}
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Serialization/BitReader.cs b/com.unity.netcode.gameobjects/Runtime/Serialization/BitReader.cs
index dcb30a92dd..92d1951a7a 100644
--- a/com.unity.netcode.gameobjects/Runtime/Serialization/BitReader.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Serialization/BitReader.cs
@@ -15,7 +15,7 @@ public ref struct BitReader
private readonly unsafe byte* m_BufferPointer;
private readonly int m_Position;
private int m_BitPosition;
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
private int m_AllowedBitwiseReadMark;
#endif
@@ -39,7 +39,7 @@ internal unsafe BitReader(FastBufferReader reader)
m_BufferPointer = m_Reader.Handle->BufferPointer + m_Reader.Handle->Position;
m_Position = m_Reader.Handle->Position;
m_BitPosition = 0;
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
m_AllowedBitwiseReadMark = (m_Reader.Handle->AllowedReadMark - m_Position) * k_BitsPerByte;
#endif
}
@@ -81,7 +81,7 @@ public unsafe bool TryBeginReadBits(uint bitCount)
{
return false;
}
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
m_AllowedBitwiseReadMark = (int)newBitPosition;
#endif
return true;
@@ -94,7 +94,7 @@ public unsafe bool TryBeginReadBits(uint bitCount)
/// Amount of bits to read
public unsafe void ReadBits(out ulong value, uint bitCount)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (bitCount > 64)
{
throw new ArgumentOutOfRangeException(nameof(bitCount), "Cannot read more than 64 bits from a 64-bit value!");
@@ -136,7 +136,7 @@ public unsafe void ReadBits(out ulong value, uint bitCount)
/// Amount of bits to read.
public void ReadBits(out byte value, uint bitCount)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
int checkPos = (int)(m_BitPosition + bitCount);
if (checkPos > m_AllowedBitwiseReadMark)
{
@@ -153,7 +153,7 @@ public void ReadBits(out byte value, uint bitCount)
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe void ReadBit(out bool bit)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
int checkPos = (m_BitPosition + 1);
if (checkPos > m_AllowedBitwiseReadMark)
{
@@ -170,7 +170,7 @@ public unsafe void ReadBit(out bool bit)
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private unsafe void ReadPartialValue(out T value, int bytesToRead, int offsetBytes = 0) where T : unmanaged
{
- var val = new T();
+ var val = default(T);
byte* ptr = ((byte*)&val) + offsetBytes;
byte* bufferPointer = m_BufferPointer + BytePosition;
UnsafeUtility.MemCpy(ptr, bufferPointer, bytesToRead);
diff --git a/com.unity.netcode.gameobjects/Runtime/Serialization/BitWriter.cs b/com.unity.netcode.gameobjects/Runtime/Serialization/BitWriter.cs
index 0e3ccfb7e3..7b38bcadc9 100644
--- a/com.unity.netcode.gameobjects/Runtime/Serialization/BitWriter.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Serialization/BitWriter.cs
@@ -15,7 +15,7 @@ public ref struct BitWriter
private unsafe byte* m_BufferPointer;
private readonly int m_Position;
private int m_BitPosition;
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
private int m_AllowedBitwiseWriteMark;
#endif
private const int k_BitsPerByte = 8;
@@ -37,7 +37,7 @@ internal unsafe BitWriter(FastBufferWriter writer)
m_BufferPointer = writer.Handle->BufferPointer + writer.Handle->Position;
m_Position = writer.Handle->Position;
m_BitPosition = 0;
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
m_AllowedBitwiseWriteMark = (m_Writer.Handle->AllowedWriteMark - m_Writer.Handle->Position) * k_BitsPerByte;
#endif
}
@@ -97,7 +97,7 @@ public unsafe bool TryBeginWriteBits(int bitCount)
return false;
}
}
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
m_AllowedBitwiseWriteMark = newBitPosition;
#endif
return true;
@@ -110,7 +110,7 @@ public unsafe bool TryBeginWriteBits(int bitCount)
/// Amount of bits to write
public unsafe void WriteBits(ulong value, uint bitCount)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (bitCount > 64)
{
throw new ArgumentOutOfRangeException(nameof(bitCount), "Cannot write more than 64 bits from a 64-bit value!");
@@ -153,7 +153,7 @@ public unsafe void WriteBits(ulong value, uint bitCount)
/// Amount of bits to write.
public void WriteBits(byte value, uint bitCount)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
int checkPos = (int)(m_BitPosition + bitCount);
if (checkPos > m_AllowedBitwiseWriteMark)
{
@@ -174,7 +174,7 @@ public void WriteBits(byte value, uint bitCount)
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe void WriteBit(bool bit)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
int checkPos = (m_BitPosition + 1);
if (checkPos > m_AllowedBitwiseWriteMark)
{
diff --git a/com.unity.netcode.gameobjects/Runtime/Serialization/FastBufferReader.cs b/com.unity.netcode.gameobjects/Runtime/Serialization/FastBufferReader.cs
index d0dfdca7cd..522e9c4bad 100644
--- a/com.unity.netcode.gameobjects/Runtime/Serialization/FastBufferReader.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Serialization/FastBufferReader.cs
@@ -20,7 +20,7 @@ internal struct ReaderHandle
internal int Position;
internal int Length;
internal Allocator Allocator;
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
internal int AllowedReadMark;
internal bool InBitwiseContext;
#endif
@@ -55,7 +55,7 @@ public unsafe int Length
internal unsafe void CommitBitwiseReads(int amount)
{
Handle->Position += amount;
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
Handle->InBitwiseContext = false;
#endif
}
@@ -83,7 +83,7 @@ internal unsafe void CommitBitwiseReads(int amount)
// When we dispose, we are really only interested in disposing Allocator.Persistent and Allocator.TempJob
// as disposing Allocator.Temp and Allocator.None would do nothing. Therefore, make sure we dispose the readerHandle with the right Allocator label
readerHandle->Allocator = copyAllocator == Allocator.None ? internalAllocator : copyAllocator;
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
readerHandle->AllowedReadMark = 0;
readerHandle->InBitwiseContext = false;
#endif
@@ -321,7 +321,7 @@ public unsafe void Seek(int where)
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal unsafe void MarkBytesRead(int amount)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->InBitwiseContext)
{
throw new InvalidOperationException(
@@ -343,7 +343,7 @@ internal unsafe void MarkBytesRead(int amount)
/// A BitReader
public unsafe BitReader EnterBitwiseContext()
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
Handle->InBitwiseContext = true;
#endif
return new BitReader(this);
@@ -366,7 +366,7 @@ public unsafe BitReader EnterBitwiseContext()
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe bool TryBeginRead(int bytes)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->InBitwiseContext)
{
throw new InvalidOperationException(
@@ -377,7 +377,7 @@ public unsafe bool TryBeginRead(int bytes)
{
return false;
}
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
Handle->AllowedReadMark = Handle->Position + bytes;
#endif
return true;
@@ -401,7 +401,7 @@ public unsafe bool TryBeginRead(int bytes)
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe bool TryBeginReadValue(in T value) where T : unmanaged
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->InBitwiseContext)
{
throw new InvalidOperationException(
@@ -413,7 +413,7 @@ public unsafe bool TryBeginReadValue(in T value) where T : unmanaged
{
return false;
}
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
Handle->AllowedReadMark = Handle->Position + len;
#endif
return true;
@@ -429,7 +429,7 @@ public unsafe bool TryBeginReadValue(in T value) where T : unmanaged
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal unsafe bool TryBeginReadInternal(int bytes)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->InBitwiseContext)
{
throw new InvalidOperationException(
@@ -440,7 +440,7 @@ internal unsafe bool TryBeginReadInternal(int bytes)
{
return false;
}
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->Position + bytes > Handle->AllowedReadMark)
{
Handle->AllowedReadMark = Handle->Position + bytes;
@@ -564,14 +564,36 @@ public void ReadNetworkSerializableInPlace(ref T value) where T : INetworkSer
}
///
- /// Reads a string
- /// NOTE: ALLOCATES
+ /// Validates the string's total byte count based on whether we are
+ /// using one or two byte characters.
///
- /// Stores the read string
- /// Whether or not to use one byte per character. This will only allow ASCII
- public unsafe void ReadValue(out string s, bool oneByteChars = false)
+ ///
+ /// Will throw an overflow exception if the size is greater than .
+ ///
+ /// Character count
+ /// If false(default) 2 byte characters and if true 1 byte characters
+ /// total size in bytes to read
+ ///
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ private int ValidateStringByteCount(int length, bool oneByteChars)
+ {
+ var readSize = oneByteChars ? length : length * sizeof(char);
+ if (int.MaxValue < (uint)readSize)
+ {
+ throw new OverflowException($"Invalid reader position detected when trying to read a string of size {(uint)readSize}! This can result from an error in the serialization. Ensure deserialization exactly matches what was serialized!");
+ }
+ return readSize;
+ }
+
+ ///
+ /// Commonly shared string read method between .
+ ///
+ /// The output of the string read.
+ /// The number of characters in the string.
+ /// If false(default) 2 byte characters and if true 1 byte characters.
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ private unsafe void ReadString(out string s, int length, bool oneByteChars)
{
- ReadLength(out int length);
s = "".PadRight(length);
int target = s.Length;
fixed (char* native = s)
@@ -592,56 +614,50 @@ public unsafe void ReadValue(out string s, bool oneByteChars = false)
}
///
- /// Reads a string.
- /// NOTE: ALLOCATES
- ///
- /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
- /// for multiple reads at once by calling TryBeginRead.
+ /// Reads a string without bounds checking.
+ /// NOTE: This method ALLOCATES memory.
///
+ ///
+ /// This is the un-safe string read which requires invoking prior to invoking this method.
+ /// Using one byte characters only allows ASCII characters.
+ ///
/// Stores the read string
- /// Whether or not to use one byte per character. This will only allow ASCII
- public unsafe void ReadValueSafe(out string s, bool oneByteChars = false)
+ /// If false(default) 2 byte characters and if true 1 byte characters.
+ public unsafe void ReadValue(out string s, bool oneByteChars = false)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
- if (Handle->InBitwiseContext)
- {
- throw new InvalidOperationException(
- "Cannot use BufferReader in bytewise mode while in a bitwise context.");
- }
-#endif
+ ReadLength(out int length);
- if (!TryBeginReadInternal(SizeOfLengthField()))
- {
- throw new OverflowException("Reading past the end of the buffer");
- }
+ // Validate the string's byte count based on the character count.
+ ValidateStringByteCount(length, oneByteChars);
- ReadLength(out int length);
+ // Read the string
+ ReadString(out s, length, oneByteChars);
+ }
+
+ ///
+ /// Reads a string after it performs bounds checking automatically.
+ /// NOTE: This method ALLOCATES memory.
+ ///
+ ///
+ /// This is the safe string read which invokes prior to reading the string.
+ /// Using one byte characters only allows ASCII characters.
+ ///
+ /// The string re the read string
+ /// If false(default) 2 byte characters and if true 1 byte characters.
+ public unsafe void ReadValueSafe(out string s, bool oneByteChars = false)
+ {
+ ReadLengthSafe(out int length);
- if (!TryBeginReadInternal(length * (oneByteChars ? 1 : sizeof(char))))
+ // Validate the string's byte count based on the character count and if it is valid begin reading based on the returned
+ // byte count.
+ if (!TryBeginReadInternal(ValidateStringByteCount(length, oneByteChars)))
{
throw new OverflowException("Reading past the end of the buffer");
}
- s = "".PadRight(length);
- int target = s.Length;
- fixed (char* native = s)
- {
- if (oneByteChars)
- {
- for (int i = 0; i < target; ++i)
- {
- ReadByte(out byte b);
- native[i] = (char)b;
- }
- }
- else
- {
- ReadBytes((byte*)native, target * sizeof(char));
- }
- }
- }
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- private static int SizeOfLengthField() => sizeof(uint);
+ // Read the string
+ ReadString(out s, length, oneByteChars);
+ }
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void ReadLengthSafe(out uint length) => ReadUnmanagedSafe(out length);
@@ -679,7 +695,7 @@ private void ReadLength(out int length)
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe void ReadPartialValue(out T value, int bytesToRead, int offsetBytes = 0) where T : unmanaged
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->InBitwiseContext)
{
throw new InvalidOperationException(
@@ -691,7 +707,7 @@ public unsafe void ReadPartialValue(out T value, int bytesToRead, int offsetB
}
#endif
- var val = new T();
+ var val = default(T);
byte* ptr = ((byte*)&val) + offsetBytes;
byte* bufferPointer = Handle->BufferPointer + Handle->Position;
UnsafeUtility.MemCpy(ptr, bufferPointer, bytesToRead);
@@ -707,7 +723,7 @@ public unsafe void ReadPartialValue(out T value, int bytesToRead, int offsetB
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe void ReadByte(out byte value)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->InBitwiseContext)
{
throw new InvalidOperationException(
@@ -731,7 +747,7 @@ public unsafe void ReadByte(out byte value)
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe void ReadByteSafe(out byte value)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->InBitwiseContext)
{
throw new InvalidOperationException(
@@ -755,7 +771,7 @@ public unsafe void ReadByteSafe(out byte value)
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe void ReadBytes(byte* value, int size, int offset = 0)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->InBitwiseContext)
{
throw new InvalidOperationException(
@@ -782,7 +798,7 @@ public unsafe void ReadBytes(byte* value, int size, int offset = 0)
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe void ReadBytesSafe(byte* value, int size, int offset = 0)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->InBitwiseContext)
{
throw new InvalidOperationException(
diff --git a/com.unity.netcode.gameobjects/Runtime/Serialization/FastBufferWriter.cs b/com.unity.netcode.gameobjects/Runtime/Serialization/FastBufferWriter.cs
index bea537965e..343822fe32 100644
--- a/com.unity.netcode.gameobjects/Runtime/Serialization/FastBufferWriter.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Serialization/FastBufferWriter.cs
@@ -23,7 +23,7 @@ internal struct WriterHandle
internal int MaxCapacity;
internal Allocator Allocator;
internal bool BufferGrew;
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
internal int AllowedWriteMark;
internal bool InBitwiseContext;
#endif
@@ -31,7 +31,7 @@ internal struct WriterHandle
internal unsafe WriterHandle* Handle;
- private static byte[] s_ByteArrayCache = new byte[65535];
+ private static readonly byte[] k_ByteArrayCache = new byte[65535];
///
/// The current write position
@@ -79,7 +79,7 @@ public unsafe int Length
internal unsafe void CommitBitwiseWrites(int amount)
{
Handle->Position += amount;
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
Handle->InBitwiseContext = false;
#endif
}
@@ -97,7 +97,7 @@ public unsafe FastBufferWriter(int size, Allocator allocator, int maxSize = -1)
// If the buffer grows, a new buffer will be allocated and the handle pointer pointed at the new location...
// The original buffer won't be deallocated until the writer is destroyed since it's part of the handle allocation.
Handle = (WriterHandle*)UnsafeUtility.Malloc(sizeof(WriterHandle) + size, UnsafeUtility.AlignOf(), allocator);
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
UnsafeUtility.MemSet(Handle, 0, sizeof(WriterHandle) + size);
#endif
Handle->BufferPointer = (byte*)(Handle + 1);
@@ -107,7 +107,7 @@ public unsafe FastBufferWriter(int size, Allocator allocator, int maxSize = -1)
Handle->Allocator = allocator;
Handle->MaxCapacity = maxSize < size ? size : maxSize;
Handle->BufferGrew = false;
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
Handle->AllowedWriteMark = 0;
Handle->InBitwiseContext = false;
#endif
@@ -185,7 +185,7 @@ public unsafe void Truncate(int where = -1)
/// A BitWriter
public unsafe BitWriter EnterBitwiseContext()
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
Handle->InBitwiseContext = true;
#endif
return new BitWriter(this);
@@ -201,7 +201,7 @@ internal unsafe void Grow(int additionalSizeRequired)
var newSize = Math.Min(desiredSize, Handle->MaxCapacity);
byte* newBuffer = (byte*)UnsafeUtility.Malloc(newSize, UnsafeUtility.AlignOf(), Handle->Allocator);
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
UnsafeUtility.MemSet(newBuffer, 0, newSize);
#endif
UnsafeUtility.MemCpy(newBuffer, Handle->BufferPointer, Length);
@@ -232,7 +232,7 @@ internal unsafe void Grow(int additionalSizeRequired)
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe bool TryBeginWrite(int bytes)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->InBitwiseContext)
{
throw new InvalidOperationException(
@@ -255,7 +255,7 @@ public unsafe bool TryBeginWrite(int bytes)
return false;
}
}
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
Handle->AllowedWriteMark = Handle->Position + bytes;
#endif
return true;
@@ -280,7 +280,7 @@ public unsafe bool TryBeginWrite(int bytes)
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe bool TryBeginWriteValue(in T value) where T : unmanaged
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->InBitwiseContext)
{
throw new InvalidOperationException(
@@ -304,7 +304,7 @@ public unsafe bool TryBeginWriteValue(in T value) where T : unmanaged
return false;
}
}
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
Handle->AllowedWriteMark = Handle->Position + len;
#endif
return true;
@@ -320,7 +320,7 @@ public unsafe bool TryBeginWriteValue(in T value) where T : unmanaged
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe bool TryBeginWriteInternal(int bytes)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->InBitwiseContext)
{
throw new InvalidOperationException(
@@ -343,7 +343,7 @@ public unsafe bool TryBeginWriteInternal(int bytes)
return false;
}
}
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->Position + bytes > Handle->AllowedWriteMark)
{
Handle->AllowedWriteMark = Handle->Position + bytes;
@@ -379,17 +379,17 @@ public unsafe byte[] ToArray()
internal unsafe ArraySegment ToTempByteArray()
{
var length = Length;
- if (length > s_ByteArrayCache.Length)
+ if (length > k_ByteArrayCache.Length)
{
return new ArraySegment(ToArray(), 0, length);
}
- fixed (byte* b = s_ByteArrayCache)
+ fixed (byte* b = k_ByteArrayCache)
{
UnsafeUtility.MemCpy(b, Handle->BufferPointer, length);
}
- return new ArraySegment(s_ByteArrayCache, 0, length);
+ return new ArraySegment(k_ByteArrayCache, 0, length);
}
///
@@ -523,7 +523,7 @@ public unsafe void WriteValue(string s, bool oneByteChars = false)
/// Whether or not to use one byte per character. This will only allow ASCII
public unsafe void WriteValueSafe(string s, bool oneByteChars = false)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->InBitwiseContext)
{
throw new InvalidOperationException(
@@ -618,7 +618,7 @@ public static unsafe int GetWriteSize(NativeList array, int count = -1, in
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe void WritePartialValue(T value, int bytesToWrite, int offsetBytes = 0) where T : unmanaged
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->InBitwiseContext)
{
throw new InvalidOperationException(
@@ -644,7 +644,7 @@ public unsafe void WritePartialValue(T value, int bytesToWrite, int offsetByt
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe void WriteByte(byte value)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->InBitwiseContext)
{
throw new InvalidOperationException(
@@ -668,7 +668,7 @@ public unsafe void WriteByte(byte value)
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe void WriteByteSafe(byte value)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->InBitwiseContext)
{
throw new InvalidOperationException(
@@ -692,7 +692,7 @@ public unsafe void WriteByteSafe(byte value)
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe void WriteBytes(byte* value, int size, int offset = 0)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->InBitwiseContext)
{
throw new InvalidOperationException(
@@ -719,7 +719,7 @@ public unsafe void WriteBytes(byte* value, int size, int offset = 0)
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe void WriteBytesSafe(byte* value, int size, int offset = 0)
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
if (Handle->InBitwiseContext)
{
throw new InvalidOperationException(
diff --git a/com.unity.netcode.gameobjects/Runtime/Serialization/NetworkBehaviourReference.cs b/com.unity.netcode.gameobjects/Runtime/Serialization/NetworkBehaviourReference.cs
index 19cecefc48..0b2e406e4f 100644
--- a/com.unity.netcode.gameobjects/Runtime/Serialization/NetworkBehaviourReference.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Serialization/NetworkBehaviourReference.cs
@@ -11,8 +11,7 @@ public struct NetworkBehaviourReference : INetworkSerializable, IEquatable
/// Creates a new instance of the struct.
@@ -24,7 +23,7 @@ public NetworkBehaviourReference(NetworkBehaviour networkBehaviour)
if (networkBehaviour == null)
{
m_NetworkObjectReference = new NetworkObjectReference((NetworkObject)null);
- m_NetworkBehaviourId = s_NullId;
+ m_NetworkBehaviourId = k_NullId;
return;
}
if (networkBehaviour.NetworkObject == null)
@@ -64,7 +63,7 @@ public bool TryGet(out T networkBehaviour, NetworkManager networkManager = nu
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static NetworkBehaviour GetInternal(NetworkBehaviourReference networkBehaviourRef, NetworkManager networkManager = null)
{
- if (networkBehaviourRef.m_NetworkBehaviourId == s_NullId)
+ if (networkBehaviourRef.m_NetworkBehaviourId == k_NullId)
{
return null;
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Serialization/NetworkObjectReference.cs b/com.unity.netcode.gameobjects/Runtime/Serialization/NetworkObjectReference.cs
index 32ab0ed162..db5ed69ced 100644
--- a/com.unity.netcode.gameobjects/Runtime/Serialization/NetworkObjectReference.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Serialization/NetworkObjectReference.cs
@@ -10,7 +10,7 @@ namespace Unity.Netcode
public struct NetworkObjectReference : INetworkSerializable, IEquatable
{
private ulong m_NetworkObjectId;
- private static ulong s_NullId = ulong.MaxValue;
+ private const ulong k_NullId = ulong.MaxValue;
///
/// The of the referenced .
@@ -31,7 +31,7 @@ public NetworkObjectReference(NetworkObject networkObject)
{
if (networkObject == null)
{
- m_NetworkObjectId = s_NullId;
+ m_NetworkObjectId = k_NullId;
return;
}
@@ -53,7 +53,7 @@ public NetworkObjectReference(GameObject gameObject)
{
if (gameObject == null)
{
- m_NetworkObjectId = s_NullId;
+ m_NetworkObjectId = k_NullId;
return;
}
@@ -92,7 +92,7 @@ public bool TryGet(out NetworkObject networkObject, NetworkManager networkManage
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static NetworkObject Resolve(NetworkObjectReference networkObjectRef, NetworkManager networkManager = null)
{
- if (networkObjectRef.m_NetworkObjectId == s_NullId)
+ if (networkObjectRef.m_NetworkObjectId == k_NullId)
{
return null;
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkPrefabHandler.cs b/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkPrefabHandler.cs
index c8aab939f4..19444a4ddb 100644
--- a/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkPrefabHandler.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkPrefabHandler.cs
@@ -341,8 +341,8 @@ internal void HandleNetworkPrefabDestroy(NetworkObject networkObjectInstance)
prefabInstanceHandler.Destroy(networkObjectInstance);
}
}
- else // Otherwise the NetworkObject is the source NetworkPrefab
- if (m_PrefabAssetToPrefabHandler.TryGetValue(networkObjectInstanceHash, out var prefabInstanceHandler))
+ // Otherwise the NetworkObject is the source NetworkPrefab
+ else if (m_PrefabAssetToPrefabHandler.TryGetValue(networkObjectInstanceHash, out var prefabInstanceHandler))
{
prefabInstanceHandler.Destroy(networkObjectInstance);
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs b/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs
index 52e891f8e1..573edb7d13 100644
--- a/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs
@@ -448,6 +448,7 @@ private bool TryGetNetworkClient(ulong clientId, out NetworkClient networkClient
///
/// not used
/// not used
+ [Obsolete("This method is no longer used and will be removed in a future version.")]
protected virtual void InternalOnOwnershipChanged(ulong perviousOwner, ulong newOwner)
{
@@ -906,10 +907,7 @@ internal NetworkObject GetNetworkObjectToSpawn(uint globalObjectIdHash, ulong ow
// If not, then there is an issue (user possibly didn't register the prefab properly?)
if (networkPrefabReference == null)
{
- if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
- {
- NetworkLog.LogErrorServer($"[{nameof(globalObjectIdHash)}={globalObjectIdHash}] Failed to create object locally. {nameof(NetworkPrefab)} could not be found. Is the prefab registered with {NetworkManager.name}?");
- }
+ NetworkManager.Log.ErrorServer(new Context(LogLevel.Error, $"Failed to create object locally. {nameof(NetworkPrefab)} could not be found. Is the prefab registered with this {nameof(NetworkManager)}").AddInfo(nameof(NetworkObject.GlobalObjectIdHash), globalObjectIdHash).AddTag(NetworkManager.name));
return null;
}
@@ -956,6 +954,7 @@ internal NetworkObject InstantiateNetworkPrefab([NotNull] GameObject networkPref
///
/// For most cases this is client-side only, except when the server is spawning a player.
///
+ [return: MaybeNull]
internal NetworkObject CreateLocalNetworkObject(NetworkObject.SerializedObject serializedObject, byte[] instantiationData = null)
{
NetworkObject networkObject = null;
@@ -976,11 +975,7 @@ internal NetworkObject CreateLocalNetworkObject(NetworkObject.SerializedObject s
networkObject = NetworkManager.SceneManager.GetSceneRelativeInSceneNetworkObject(globalObjectIdHash, serializedObject.NetworkSceneHandle);
if (networkObject == null)
{
- if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
- {
- NetworkLog.LogError($"{nameof(NetworkPrefab)} hash was not found! In-Scene placed {nameof(NetworkObject)} soft synchronization failure for Hash: {globalObjectIdHash}!");
- }
-
+ NetworkLog.LogErrorServer(new Context(LogLevel.Error, $"{nameof(NetworkPrefab)} hash was not found! In-Scene placed {nameof(NetworkObject)} soft synchronization failure!").AddInfo(nameof(NetworkObject.GlobalObjectIdHash), globalObjectIdHash));
return null;
}
@@ -1121,7 +1116,13 @@ internal bool AuthorityLocalSpawn([NotNull] NetworkObject networkObject, ulong n
return false;
}
- if (!sceneObject && NetworkManager.LogLevel <= LogLevel.Error)
+ if (playerObject && networkObject.InScenePlaced)
+ {
+ NetworkLog.LogError(new Context(LogLevel.Developer, "Player prefab is marked as belonging to a scene. This may cause issues.").AddNetworkObject(networkObject).AddInfo("SceneName", networkObject.SceneOrigin.name));
+ networkObject.InScenePlaced = false;
+ }
+
+ if (!networkObject.InScenePlaced && NetworkManager.LogLevel <= LogLevel.Error)
{
var networkObjectChildren = networkObject.GetComponentsInChildren();
if (networkObjectChildren.Length > 1)
@@ -1136,48 +1137,13 @@ internal bool AuthorityLocalSpawn([NotNull] NetworkObject networkObject, ulong n
networkObject.NetworkManagerOwner = NetworkManager;
networkObject.InvokeBehaviourNetworkPreSpawn();
- // DANGO-TODO: It would be nice to allow users to specify which clients are observers prior to spawning
- // For now, this is the best place I could find to add all connected clients as observers for newly
- // instantiated and spawned NetworkObjects on the authoritative side.
- if (NetworkManager.DistributedAuthorityMode)
+ if (NetworkManager.DistributedAuthorityMode && NetworkManager.NetworkConfig.EnableSceneManagement && networkObject.InScenePlaced)
{
- if (NetworkManager.NetworkConfig.EnableSceneManagement && sceneObject)
- {
- networkObject.SceneOriginHandle = networkObject.gameObject.scene.handle;
- networkObject.NetworkSceneHandle = NetworkManager.SceneManager.ClientSceneHandleToServerSceneHandle[networkObject.gameObject.scene.handle];
- }
-
- // Always add the owner/authority even if SpawnWithObservers is false
- // (authority should not take into consideration networkObject.CheckObjectVisibility when SpawnWithObservers is false)
- if (!networkObject.SpawnWithObservers)
- {
- networkObject.AddObserver(ownerClientId);
- }
- else
- {
- foreach (var clientId in NetworkManager.ConnectionManager.ConnectedClientIds)
- {
- // If SpawnWithObservers is enabled, then authority does take networkObject.CheckObjectVisibility into consideration
- if (networkObject.CheckObjectVisibility != null && !networkObject.CheckObjectVisibility.Invoke(clientId))
- {
- continue;
- }
- networkObject.AddObserver(clientId);
- }
-
- // Sanity check to make sure the owner is always included
- // Intentionally checking as opposed to just assigning in order to generate notification.
- if (!networkObject.Observers.Contains(ownerClientId))
- {
- if (NetworkManager.LogLevel <= LogLevel.Error)
- {
- NetworkLog.LogError($"Client-{ownerClientId} is the owner of {networkObject.name} but is not an observer! Adding owner, but there is a bug in observer synchronization!");
- }
- networkObject.AddObserver(ownerClientId);
- }
- }
+ networkObject.SceneOriginHandle = networkObject.gameObject.scene.handle;
+ networkObject.NetworkSceneHandle = NetworkManager.SceneManager.ClientSceneHandleToServerSceneHandle[networkObject.gameObject.scene.handle];
}
+
if (!SpawnNetworkObjectLocallyCommon(networkObject, networkId, sceneObject, playerObject, ownerClientId, destroyWithScene))
{
if (NetworkManager.LogLevel <= LogLevel.Error)
@@ -1199,20 +1165,17 @@ internal bool AuthorityLocalSpawn([NotNull] NetworkObject networkObject, ulong n
///
/// Only spawn non-authority instances should invoke this.
/// This is invoked to instantiate an authority spawned , and
- /// is only invoked by:
+ /// is only invoked by:
///
///
- /// IMPORTANT: Pre spawn methods need to be invoked from within .
+ /// IMPORTANT: Pre spawn methods need to be invoked from within .
///
/// boolean indicating whether the spawn succeeded
- internal bool NonAuthorityLocalSpawn(in NetworkObject.SerializedObject serializedObject, out NetworkObject networkObject, FastBufferReader reader, bool destroyWithScene)
+ internal bool NonAuthorityLocalSpawn(in NetworkObject.SerializedObject serializedObject, [MaybeNullWhen(false)] out NetworkObject networkObject, FastBufferReader reader, bool destroyWithScene)
{
if (SpawnedObjects.ContainsKey(serializedObject.NetworkObjectId))
{
- if (NetworkManager.LogLevel <= LogLevel.Error)
- {
- NetworkLog.LogWarning($"Trying to spawn a {nameof(NetworkObject)} with a {nameof(NetworkObject.NetworkObjectId)} of {serializedObject.NetworkObjectId} but an object with that id is already in the spawned list. This should not happen!");
- }
+ NetworkManager.Log.Warning(new Context(LogLevel.Error, $"Trying to spawn a {nameof(NetworkObject)} but an object with that {nameof(NetworkObject.NetworkObjectId)} is already in the spawned list. This should not happen!"));
networkObject = null;
return false;
}
@@ -1229,14 +1192,11 @@ internal bool NonAuthorityLocalSpawn(in NetworkObject.SerializedObject serialize
// Log the error that the NetworkObject failed to construct
if (networkObject == null)
{
- if (NetworkManager.LogLevel <= LogLevel.Normal)
- {
- NetworkLog.LogError($"[{nameof(NetworkObject.GlobalObjectIdHash)}={serializedObject.Hash}] Failed to spawn {nameof(NetworkObject)}!");
- }
-
+ NetworkManager.Log.ErrorServer(new Context(LogLevel.Normal, $"Failed to spawn {nameof(NetworkObject)}!").AddInfo(nameof(NetworkObject.GlobalObjectIdHash), serializedObject.Hash));
return false;
}
+ networkObject.InScenePlaced = serializedObject.IsSceneObject;
networkObject.NetworkManagerOwner = NetworkManager;
// This will get set again when the NetworkObject is spawned locally, but we set it here ahead of spawning
@@ -1261,11 +1221,7 @@ internal bool NonAuthorityLocalSpawn(in NetworkObject.SerializedObject serialize
if (networkObject.IsSpawned)
{
- if (NetworkManager.LogLevel <= LogLevel.Error)
- {
- NetworkLog.LogErrorServer($"[{networkObject.name}] Object-{networkObject.NetworkObjectId} is already spawned!");
- }
-
+ NetworkManager.Log.ErrorServer(new Context(LogLevel.Normal, $"{nameof(NetworkObject)} is already spawned!").AddNetworkObject(networkObject));
// Mark the spawn as a success if the object is already spawned
return true;
}
@@ -1294,9 +1250,10 @@ internal bool NonAuthorityLocalSpawn(in NetworkObject.SerializedObject serialize
}
///
- /// Handles the all the final setup and spawning needed for
+ /// Handles all the final setup and spawning needed for spawning a NetworkObject locally.
///
- /// boolean indicating whether the spawn succeeded. Internal dev note: THIS IS A CATCH FOR OURSELVES. DON'T PULL OUT
+ /// boolean indicating whether the spawn succeeded.
+ // Internal dev note: THIS IS A CATCH FOR OURSELVES. DON'T PULL OUT
internal bool SpawnNetworkObjectLocallyCommon(NetworkObject networkObject, ulong networkId, bool sceneObject, bool playerObject, ulong ownerClientId, bool destroyWithScene)
{
// TODO: Replace the following checks with internal Netcode asserts
@@ -1310,7 +1267,7 @@ internal bool SpawnNetworkObjectLocallyCommon(NetworkObject networkObject, ulong
return false;
}
- if (networkId == default)
+ if (networkId == 0)
{
if (NetworkManager.LogLevel <= LogLevel.Error)
{
@@ -1319,95 +1276,29 @@ internal bool SpawnNetworkObjectLocallyCommon(NetworkObject networkObject, ulong
return false;
}
- networkObject.IsSceneObject = sceneObject;
-
- // Always check to make sure our scene of origin is properly set for in-scene placed NetworkObjects
- // Note: Always check SceneOriginHandle directly at this specific location.
- if (networkObject.IsSceneObject != false && networkObject.SceneOriginHandle.IsEmpty())
- {
- networkObject.SceneOrigin = networkObject.gameObject.scene;
- }
-
- networkObject.NetworkObjectId = networkId;
-
- networkObject.DestroyWithScene = sceneObject || destroyWithScene;
+#pragma warning disable CS0618 // Type or member is obsolete
+ // Obsolete with warning means we need the underlying behaviour to keep existing
+ // TODO: remove in the 3.x branch
+ networkObject.SetSceneObjectStatus(sceneObject);
+#pragma warning restore CS0618 // Type or member is obsolete
- networkObject.IsPlayerObject = playerObject;
+ networkObject.SetupOnSpawn(networkId, playerObject, ownerClientId, destroyWithScene);
- networkObject.OwnerClientId = ownerClientId;
-
- // When spawned, previous owner is always the first assigned owner
- networkObject.PreviousOwnerId = ownerClientId;
-
- // If this the player and the client is the owner, then lock ownership by default
- if (NetworkManager.DistributedAuthorityMode && NetworkManager.LocalClientId == ownerClientId && playerObject)
- {
- networkObject.AddOwnershipExtended(NetworkObject.OwnershipStatusExtended.Locked);
- }
-
- networkObject.IsSpawned = true;
SpawnedObjects.Add(networkObject.NetworkObjectId, networkObject);
SpawnedObjectsList.Add(networkObject);
-
- // If we are not running in DA mode, this is the server, and the NetworkObject has SpawnWithObservers set,
- // then add all connected clients as observers
- if (!NetworkManager.DistributedAuthorityMode && NetworkManager.IsServer && networkObject.SpawnWithObservers)
- {
- // If running as a server only, then make sure to always add the server's client identifier
- if (!NetworkManager.IsHost)
- {
- networkObject.AddObserver(NetworkManager.LocalClientId);
- }
-
- // Add client observers
- for (int i = 0; i < NetworkManager.ConnectedClientsIds.Count; i++)
- {
- // If CheckObjectVisibility has a callback, then allow that method determine who the observers are.
- if (networkObject.CheckObjectVisibility != null && !networkObject.CheckObjectVisibility(NetworkManager.ConnectedClientsIds[i]))
- {
- continue;
- }
- networkObject.AddObserver(NetworkManager.ConnectedClientsIds[i]);
- }
- }
-
networkObject.ApplyNetworkParenting();
+
NetworkObject.CheckOrphanChildren();
AddNetworkObjectToSceneChangedUpdates(networkObject);
-
+ UpdateOwnershipTable(networkObject, ownerClientId);
networkObject.InvokeBehaviourNetworkSpawn();
- // propagate the IsSceneObject setting to child NetworkObjects
- 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;
- }
-
- // Only dynamically spawned NetworkObjects are allowed
- if (!sceneObject)
- {
- networkObject.SubscribeToActiveSceneForSynch();
- }
-
if (networkObject.IsPlayerObject)
{
UpdateNetworkClientPlayer(networkObject);
}
- // If we are an in-scene placed NetworkObject and our InScenePlacedSourceGlobalObjectIdHash is set
- // then assign this to the PrefabGlobalObjectIdHash
- if (networkObject.IsSceneObject.Value && networkObject.InScenePlacedSourceGlobalObjectIdHash != 0)
- {
- networkObject.PrefabGlobalObjectIdHash = networkObject.InScenePlacedSourceGlobalObjectIdHash;
- }
-
return true;
}
@@ -1467,7 +1358,7 @@ internal void SendSpawnCallForObject(ulong clientId, NetworkObject networkObject
}
var message = new CreateObjectMessage
{
- ObjectInfo = networkObject.Serialize(clientId, NetworkManager.DistributedAuthorityMode),
+ ObjectInfo = networkObject.SerializeSpawnedObject(clientId, NetworkManager.DistributedAuthorityMode),
IncludesSerializedObject = true,
UpdateObservers = NetworkManager.DistributedAuthorityMode,
ObserverIds = NetworkManager.DistributedAuthorityMode ? networkObject.Observers.ToArray() : null,
@@ -1493,7 +1384,7 @@ internal void SendSpawnCallForObserverUpdate(ulong[] newObservers, NetworkObject
var message = new CreateObjectMessage
{
- ObjectInfo = networkObject.Serialize(),
+ ObjectInfo = networkObject.SerializeSpawnedObject(),
ObserverIds = networkObject.Observers.ToArray(),
NewObserverIds = newObservers.ToArray(),
IncludesSerializedObject = true,
@@ -1551,14 +1442,16 @@ internal void DespawnObject(NetworkObject networkObject, bool destroyObject = fa
}
// Makes scene objects ready to be reused
- internal void ServerResetShudownStateForSceneObjects()
+ internal void ServerResetShutdownStateForSceneObjects()
{
- var networkObjects = FindObjects.ByType(orderByIdentifier: true).Where((c) => c.IsSceneObject != null && c.IsSceneObject == true);
- foreach (var sobj in networkObjects)
+ var networkObjects = FindObjects.ByType(orderByIdentifier: true, includeInactive: true);
+ foreach (var obj in networkObjects)
{
- sobj.IsSpawned = false;
- sobj.DestroyWithScene = false;
- sobj.IsSceneObject = null;
+ // Only reset things that have been spawned are in-scene placed, and is assigned to the relative NetworkManager (for integration testing purposes)
+ if (obj.HasBeenSpawned && obj.InScenePlaced && obj.NetworkManagerOwner == NetworkManager)
+ {
+ obj.ResetOnShutdown();
+ }
}
}
@@ -1574,7 +1467,7 @@ internal void ServerDestroySpawnedSceneObjects()
foreach (var networkObject in spawnedObjects)
{
- if (networkObject.IsSceneObject != null && networkObject.IsSceneObject.Value && networkObject.DestroyWithScene
+ if (networkObject.InScenePlaced && networkObject.DestroyWithScene
&& networkObject.gameObject.scene != NetworkManager.SceneManager.DontDestroyOnLoadScene)
{
if (networkObject.IsSpawned && networkObject.HasAuthority)
@@ -1618,7 +1511,7 @@ internal void DespawnAndDestroyNetworkObjects()
{
// If it is an in-scene placed NetworkObject then just despawn and let it be destroyed when the scene
// is unloaded. Otherwise, despawn and destroy it.
- var shouldDestroy = !(networkObject.IsSceneObject == null || (networkObject.IsSceneObject != null && networkObject.IsSceneObject.Value));
+ var shouldDestroy = !networkObject.InScenePlaced;
// If we are going to destroy this NetworkObject, check for any in-scene placed children that need to be removed
if (shouldDestroy)
@@ -1634,7 +1527,7 @@ internal void DespawnAndDestroyNetworkObjects()
// If the child is an in-scene placed NetworkObject then remove the child from the parent (which was dynamically spawned)
// and set its parent to root
- if (childObject.IsSceneObject != null && childObject.IsSceneObject.Value)
+ if (childObject.InScenePlaced)
{
childObject.TryRemoveParentCachedWorldPositionStays();
}
@@ -1653,27 +1546,24 @@ internal void DestroySceneObjects()
for (int i = 0; i < networkObjects.Length; i++)
{
- if (networkObjects[i].NetworkManager == NetworkManager)
+ if (networkObjects[i].NetworkManager == NetworkManager && networkObjects[i].InScenePlaced)
{
- if (networkObjects[i].IsSceneObject == null || networkObjects[i].IsSceneObject.Value == true)
+ if (NetworkManager.PrefabHandler.ContainsHandler(networkObjects[i]))
{
- if (NetworkManager.PrefabHandler.ContainsHandler(networkObjects[i]))
+ if (SpawnedObjects.ContainsKey(networkObjects[i].NetworkObjectId))
{
- if (SpawnedObjects.ContainsKey(networkObjects[i].NetworkObjectId))
- {
- // This method invokes HandleNetworkPrefabDestroy, we only want to handle this once.
- OnDespawnObject(networkObjects[i], false);
- }
- else // If not spawned, then just invoke the handler
- {
- NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(networkObjects[i]);
- }
+ // This method invokes HandleNetworkPrefabDestroy, we only want to handle this once.
+ OnDespawnObject(networkObjects[i], false);
}
- else
+ else // If not spawned, then just invoke the handler
{
- Object.Destroy(networkObjects[i].gameObject);
+ NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(networkObjects[i]);
}
}
+ else
+ {
+ Object.Destroy(networkObjects[i].gameObject);
+ }
}
}
}
@@ -1689,10 +1579,48 @@ internal void ServerSpawnSceneObjectsOnStartSweep()
continue;
}
- // This used to be two loops.
- // The first added all NetworkObjects to a list and the second spawned all NetworkObjects in the list.
- // Now, a parent will set its children's IsSceneObject value when spawned, so we check for null or for true.
- if (networkObject.IsSceneObject == null || (networkObject.IsSceneObject.HasValue && networkObject.IsSceneObject.Value))
+ // Do not attempt to spawn if it is the actual prefab asset itself:
+ // - This is not supported by NGO.
+ // - This will lead to other issues if it gets destroyed, when de-spawned, but the prefab is still registered.
+ // - This also prevents from spawning integration test prefabs.
+ if (NetworkManager.NetworkConfig.Prefabs.IsActualPrefabAsset(networkObject))
+ {
+ NetworkManager.Log.Warning(new Context(LogLevel.Developer, $"Skipping {networkObject.name} as it is the actual prefab asset itself!"));
+ continue;
+ }
+
+ // Determine if this is even a valid thing to spawn:
+ // - If it is not based on a registered prefab, it is invalid.
+ // - If the GlobalObjectIdHash is zero, it is invalid.
+ var isValidInstanceToSpawn = NetworkManager.NetworkConfig.Prefabs.IsBasedOnRegisteredPrefab(networkObject) && networkObject.GlobalObjectIdHash != 0;
+
+ // If we are a valid prefab asset, marked as in-scene placed, but this was marked during runtime by the post processor.
+ if (isValidInstanceToSpawn && networkObject.InScenePlaced && networkObject.InScenePlacedPostProcessorMarkedDuringRuntime)
+ {
+ // Then it is not in-scene placed and was pre-instantiated. Spawn dynamically.
+ networkObject.InScenePlaced = false;
+ }
+ else if (networkObject.InScenePlaced && !networkObject.InScenePlacedPostProcessorMarkedDuringRuntime)
+ {
+ // If this was marked as in-scene placed within the editor, then it is valid.
+ isValidInstanceToSpawn = true;
+ }
+
+ var wasPreInstantiated = !networkObject.IsSpawned && !networkObject.InScenePlaced;
+
+ // Dynamically created NetworkObjects instances are not supported and will not be spawned during the sweep.
+ if (wasPreInstantiated && !isValidInstanceToSpawn)
+ {
+ NetworkManager.Log.Error(new Context(LogLevel.Error, $"Detected a pre-instantiated {nameof(GameObject)} " +
+ $"with a {nameof(NetworkObject)} component instance that is not a registered prefab nor an in-scene placed {nameof(NetworkObject)}." +
+ $" Dynamically creating unregistered {nameof(NetworkObject)}s is not supported! This {nameof(NetworkObject)} will not be spawned.").AddNetworkObject(networkObject));
+ continue;
+ }
+
+ // The only valid things to spawn during the sweep are:
+ // - In-scene placed NetworkObjects.
+ // - Pre-instantiated NetworkObjects that are registered with the NetworkManager's network prefab list(s).
+ if (networkObject.InScenePlaced || wasPreInstantiated)
{
var ownerId = networkObject.OwnerClientId;
if (NetworkManager.DistributedAuthorityMode)
@@ -1743,7 +1671,7 @@ internal void OnDespawnNonAuthorityObject([NotNull] NetworkObject networkObject,
}
}
- if (networkObject.IsSceneObject == false)
+ if (!networkObject.InScenePlaced)
{
// If the object is not an in-scene placed NetworkObject, then we always destroy the object on the non-authority side
destroyGameObject = true;
@@ -1785,7 +1713,7 @@ internal void OnDespawnObject([NotNull] NetworkObject networkObject, bool destro
// DistributedAuthorityMode: All clients need to remove the parent locally due to mixed-authority hierarchies and race-conditions
if (!NetworkManager.ShutdownInProgress && (NetworkManager.IsServer || distributedAuthority))
{
- if (destroyGameObject && networkObject.IsSceneObject == true && !NetworkManager.SceneManager.IsSceneUnloading(networkObject))
+ if (destroyGameObject && networkObject.InScenePlaced && !NetworkManager.SceneManager.IsSceneUnloading(networkObject))
{
if (NetworkManager.LogLevel <= LogLevel.Normal)
{
@@ -1825,8 +1753,7 @@ internal void OnDespawnObject([NotNull] NetworkObject networkObject, bool destro
NetworkLog.LogError($"{nameof(NetworkObject)} #{spawnedNetObj.NetworkObjectId} could not be moved to the root when its parent {nameof(NetworkObject)} #{networkObject.NetworkObjectId} was being destroyed");
}
}
- else
- if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
+ else if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
{
NetworkLog.LogWarning($"{nameof(NetworkObject)} #{spawnedNetObj.NetworkObjectId} moved to the root because its parent {nameof(NetworkObject)} #{networkObject.NetworkObjectId} is destroyed");
}
@@ -2112,7 +2039,7 @@ internal void GetObjectDistribution(ulong clientId, ref Dictionary
private const double k_DefaultAdjustmentRatio = 0.01d;
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
private static ProfilerMarker s_SyncTime = new ProfilerMarker($"{nameof(NetworkManager)}.SyncTime");
#endif
private double m_PreviousTimeSec;
@@ -182,7 +182,7 @@ internal void UpdateTime()
///
private void OnTickSyncTime()
{
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
s_SyncTime.Begin();
#endif
@@ -196,7 +196,7 @@ private void OnTickSyncTime()
m_ConnectionManager.SendMessage(ref message, m_NetworkDelivery, m_ConnectionManager.ConnectedClientIds);
}
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEBUG
s_SyncTime.End();
#endif
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Transports/SinglePlayer/SinglePlayerTransport.cs b/com.unity.netcode.gameobjects/Runtime/Transports/SinglePlayer/SinglePlayerTransport.cs
index 7b2d6b1719..e94955618c 100644
--- a/com.unity.netcode.gameobjects/Runtime/Transports/SinglePlayer/SinglePlayerTransport.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Transports/SinglePlayer/SinglePlayerTransport.cs
@@ -20,7 +20,7 @@ public class SinglePlayerTransport : NetworkTransport
///
public override ulong ServerClientId { get; } = 0;
- internal static string NotStartingAsHostErrorMessage = $"When using {nameof(SinglePlayerTransport)}, you must start a hosted session so both client and server are available locally.";
+ internal static readonly string NotStartingAsHostErrorMessage = $"When using {nameof(SinglePlayerTransport)}, you must start a hosted session so both client and server are available locally.";
private struct MessageData
{
@@ -31,6 +31,10 @@ private struct MessageData
}
private static Dictionary> s_MessageQueue = new Dictionary>();
+#if UNITY_EDITOR
+ [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+ private static void ResetStaticsOnLoad() => s_MessageQueue = new Dictionary>();
+#endif
private ulong m_TransportId = 0;
private NetworkManager m_NetworkManager;
diff --git a/com.unity.netcode.gameobjects/Runtime/Transports/UTP/INetworkStreamDriverConstructor.cs b/com.unity.netcode.gameobjects/Runtime/Transports/UTP/INetworkStreamDriverConstructor.cs
index 8e07c0d3e4..c07c8c1484 100644
--- a/com.unity.netcode.gameobjects/Runtime/Transports/UTP/INetworkStreamDriverConstructor.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Transports/UTP/INetworkStreamDriverConstructor.cs
@@ -36,9 +36,8 @@ namespace Unity.Netcode.Transports.UTP
/// var settings = transport.GetDefaultNetworkSettings();
/// driver = NetworkDriver.Create(new IPCNetworkInterface(), settings);
///
- /// driver.RegisterPipelineStage(new NetworkMetricsPipelineStage());
- ///
/// transport.GetDefaultPipelineConfigurations(
+ /// ref driver,
/// out var unreliableFragmentedPipelineStages,
/// out var unreliableSequencedFragmentedPipelineStages,
/// out var reliableSequencedPipelineStages);
diff --git a/com.unity.netcode.gameobjects/Runtime/Transports/UTP/NetworkMetricsPipelineStage.cs b/com.unity.netcode.gameobjects/Runtime/Transports/UTP/NetworkMetricsPipelineStage.cs
index c602aef739..de1e7899b9 100644
--- a/com.unity.netcode.gameobjects/Runtime/Transports/UTP/NetworkMetricsPipelineStage.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Transports/UTP/NetworkMetricsPipelineStage.cs
@@ -1,5 +1,3 @@
-#if MULTIPLAYER_TOOLS
-#if MULTIPLAYER_TOOLS_1_0_0_PRE_7
using AOT;
using Unity.Burst;
using Unity.Collections.LowLevel.Unsafe;
@@ -70,5 +68,3 @@ private static void InitializeConnection(byte* staticInstanceBuffer, int staticI
}
}
}
-#endif
-#endif
diff --git a/com.unity.netcode.gameobjects/Runtime/Transports/UTP/UnityTransport.cs b/com.unity.netcode.gameobjects/Runtime/Transports/UTP/UnityTransport.cs
index b39fe2bc94..f8ce9d815c 100644
--- a/com.unity.netcode.gameobjects/Runtime/Transports/UTP/UnityTransport.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Transports/UTP/UnityTransport.cs
@@ -1,7 +1,7 @@
// NetSim Implementation compilation boilerplate
// All references to UNITY_MP_TOOLS_NETSIM_IMPLEMENTATION_ENABLED should be defined in the same way,
// as any discrepancies are likely to result in build failures
-#if UNITY_EDITOR || (DEVELOPMENT_BUILD && !UNITY_MP_TOOLS_NETSIM_DISABLED_IN_DEVELOP) || (!DEVELOPMENT_BUILD && UNITY_MP_TOOLS_NETSIM_ENABLED_IN_RELEASE)
+#if UNITY_EDITOR || (DEBUG && !UNITY_MP_TOOLS_NETSIM_DISABLED_IN_DEVELOP) || (!DEBUG && UNITY_MP_TOOLS_NETSIM_ENABLED_IN_RELEASE)
#define UNITY_MP_TOOLS_NETSIM_IMPLEMENTATION_ENABLED
#endif
@@ -68,7 +68,7 @@ public enum ProtocolType
// frame at 60 FPS. This will be a large over-estimation in any realistic scenario.
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, WebSocketPath = "/", ServerListenAddress = string.Empty };
+ private static readonly ConnectionAddressData k_DefaultConnectionAddressData = new ConnectionAddressData { Address = "127.0.0.1", Port = 7777, WebSocketPath = "/", ServerListenAddress = string.Empty };
#pragma warning disable IDE1006 // Naming Styles
///
@@ -308,7 +308,7 @@ public NetworkEndpoint ListenEndPoint
/// This is where you can change IP Address, Port, or server's listen address.
///
///
- public ConnectionAddressData ConnectionData = s_DefaultConnectionAddressData;
+ public ConnectionAddressData ConnectionData = k_DefaultConnectionAddressData;
///
/// Parameters for the Network Simulator
@@ -369,6 +369,19 @@ private struct PacketLossCache
#endif
internal static event Action TransportInitialized;
internal static event Action TransportDisposed;
+#if UNITY_EDITOR
+ [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+ private static void ResetStaticsOnLoad()
+ {
+ s_DriverConstructor = null;
+#if UNITY_6000_2_OR_NEWER
+ OnDriverInitialized = null;
+ OnDisposingDriver = null;
+#endif
+ TransportInitialized = null;
+ TransportDisposed = null;
+ }
+#endif
///
/// Provides access to the for this instance.
@@ -507,6 +520,14 @@ public NetworkSettings GetDefaultNetworkSettings()
receiveQueueCapacity: m_MaxPacketQueueSize,
heartbeatTimeoutMS: m_HeartbeatTimeoutMS);
+ // Disable PMTU discovery if using DA, leave it at its default otherwise.
+ if (OnCurrentTopology() == NetworkTopologyTypes.DistributedAuthority)
+ {
+ var config = settings.GetNetworkConfigParameters();
+ config.performPathMtuDiscovery = false;
+ settings.AddRawParameterStruct(ref config);
+ }
+
// Configure Relay if in use.
if (m_ProtocolType == ProtocolType.RelayUnityTransport)
{
@@ -657,6 +678,23 @@ public void GetDefaultPipelineConfigurations(
reliableSequencedPipelineStages = new(reliableSequenced, Allocator.Temp);
}
+ ///
+ /// Driver for which the pipeline configurations are being retrieved.
+ public void GetDefaultPipelineConfigurations(
+ ref NetworkDriver driver,
+ out NativeArray unreliableFragmentedPipelineStages,
+ out NativeArray unreliableSequencedFragmentedPipelineStages,
+ out NativeArray reliableSequencedPipelineStages)
+ {
+#if MULTIPLAYER_TOOLS_1_0_0_PRE_7
+ driver.RegisterPipelineStage(new NetworkMetricsPipelineStage());
+#endif
+ GetDefaultPipelineConfigurations(
+ out unreliableFragmentedPipelineStages,
+ out unreliableSequencedFragmentedPipelineStages,
+ out reliableSequencedPipelineStages);
+ }
+
private NetworkPipeline SelectSendPipeline(NetworkDelivery delivery)
{
switch (delivery)
@@ -839,7 +877,7 @@ private bool ParseCommandLineOptionsPort(out ushort port)
return true;
}
#else
- if (CommandLineOptions.Instance.GetArg(k_OverridePortArg) is string argValue)
+ if (CommandLineOptions.TryGetArg(k_OverridePortArg, out var argValue))
{
port = (ushort)Convert.ChangeType(argValue, typeof(ushort));
return true;
@@ -851,7 +889,7 @@ private bool ParseCommandLineOptionsPort(out ushort port)
private bool ParseCommandLineOptionsAddress(out string ipValue)
{
- if (CommandLineOptions.Instance.GetArg(k_OverrideIpAddressArg) is string argValue)
+ if (CommandLineOptions.TryGetArg(k_OverrideIpAddressArg, out var argValue))
{
ipValue = argValue;
return true;
@@ -1860,11 +1898,8 @@ public void CreateDriver(
#endif
}
-#if MULTIPLAYER_TOOLS_1_0_0_PRE_7
- driver.RegisterPipelineStage(new NetworkMetricsPipelineStage());
-#endif
-
GetDefaultPipelineConfigurations(
+ ref driver,
out var unreliableFragmentedPipelineStages,
out var unreliableSequencedFragmentedPipelineStages,
out var reliableSequencedPipelineStages);
diff --git a/com.unity.netcode.gameobjects/Tests/Editor/Build/BuildTests.cs b/com.unity.netcode.gameobjects/Tests/Editor/Build/BuildTests.cs
index 7ee23412bf..1bb2238479 100644
--- a/com.unity.netcode.gameobjects/Tests/Editor/Build/BuildTests.cs
+++ b/com.unity.netcode.gameobjects/Tests/Editor/Build/BuildTests.cs
@@ -1,3 +1,4 @@
+#if !NGO_EXCLUDE_HEAVY_TESTS
using System.IO;
using System.Reflection;
using NUnit.Framework;
@@ -40,3 +41,4 @@ public void BasicBuildTest()
}
}
}
+#endif
diff --git a/com.unity.netcode.gameobjects/Tests/Editor/DocumentationCodeSamples.meta b/com.unity.netcode.gameobjects/Tests/Editor/DocumentationCodeSamples.meta
new file mode 100644
index 0000000000..bc0cce73b4
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Tests/Editor/DocumentationCodeSamples.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0f959eedfa8244038f30beb1f00b8cf0
+timeCreated: 1780100790
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Tests/Editor/DocumentationCodeSamples/README.md b/com.unity.netcode.gameobjects/Tests/Editor/DocumentationCodeSamples/README.md
new file mode 100644
index 0000000000..33ca58ffcc
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Tests/Editor/DocumentationCodeSamples/README.md
@@ -0,0 +1,31 @@
+# Code documentation
+
+Use this folder for any code snippets that only need to compile.
+
+Any code snippets that you want to run tests on should be put in [Runtime tests](../../Runtime/Documentation/README.md).
+
+To embed code in documentation, use the following tag
+
+```md
+[!code-cs[](../../Tests/Editor/DocumentationCodeSamples/.cs#SomeRegionName)]
+```
+
+With the code formatted like this
+
+```cs
+namespace DocumentationCodeSamples
+{
+ internal MyTestClass
+ {
+ #region SomeRegionName
+ // All the code in this region block will be embedded without indentation in the docs.
+ #endregion
+
+ [Test]
+ public void TestOfDocumentationCode()
+ {
+ ...
+ }
+ }
+}
+```
diff --git a/com.unity.netcode.gameobjects/Tests/Editor/DocumentationCodeSamples/README.md.meta b/com.unity.netcode.gameobjects/Tests/Editor/DocumentationCodeSamples/README.md.meta
new file mode 100644
index 0000000000..d43f352993
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Tests/Editor/DocumentationCodeSamples/README.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: a6afff0520856465a9f94b9a5bcebf24
+TextScriptImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
diff --git a/com.unity.netcode.gameobjects/Tests/Editor/DocumentationCodeSamples/Serialization.meta b/com.unity.netcode.gameobjects/Tests/Editor/DocumentationCodeSamples/Serialization.meta
new file mode 100644
index 0000000000..677d24fb22
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Tests/Editor/DocumentationCodeSamples/Serialization.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9371809eac694274ad78a6e7faf27e69
+timeCreated: 1780674489
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Tests/Editor/DocumentationCodeSamples/Serialization/SerializationCustomization.cs b/com.unity.netcode.gameobjects/Tests/Editor/DocumentationCodeSamples/Serialization/SerializationCustomization.cs
new file mode 100644
index 0000000000..3f70a15cb7
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Tests/Editor/DocumentationCodeSamples/Serialization/SerializationCustomization.cs
@@ -0,0 +1,114 @@
+using NUnit.Framework;
+using Unity.Collections;
+using Unity.Netcode;
+
+namespace DocumentationCodeSamples
+{
+ #region HealthStruct
+ /// Container for storing health data for a player or item.
+ public struct Health
+ {
+ ///
+ /// The maximum health that this player or item can have.
+ /// This is unlikely to change often.
+ ///
+ public uint MaxHealth;
+
+ ///
+ /// The current level of health that this player or item has.
+ /// This is likely to change regularly.
+ ///
+ public int CurrentHealth;
+ }
+ #endregion
+
+ #region FastBuffer
+ /// Tells the Netcode how to serialize and deserialize our custom type.
+ // The class name doesn't matter here.
+ public static class FastBufferExtensions
+ {
+ ///
+ /// Extension method to override the serialization for a custom type.
+ ///
+ /// Buffer to write values into.
+ /// The type to customize or override.
+ public static void WriteValueSafe(this FastBufferWriter writer, in Health health)
+ {
+ writer.WriteValueSafe(health.MaxHealth);
+ writer.WriteValueSafe(health.CurrentHealth);
+ }
+
+ ///
+ /// Extension method to override the de-serialization for a custom type.
+ ///
+ /// Buffer to read values from.
+ /// The type to customize or override.
+ public static void ReadValueSafe(this FastBufferReader reader, out Health health)
+ {
+ reader.ReadValueSafe(out uint max);
+ reader.ReadValueSafe(out int current);
+ health = new Health { MaxHealth = max, CurrentHealth = current };
+ }
+ }
+ #endregion
+
+ #region BufferSerializer
+ /// Tells the how to serialize and deserialize our custom type.
+ // The class name doesn't matter here.
+ public static class BufferSerializerExtensions
+ {
+ ///
+ /// Extension method to override bi-directional serialization for a custom type.
+ ///
+ /// Bi-directional serial
+ /// The type to customize or override.
+ /// Boilerplate syntax to enable the bi-directional serialization.
+ public static void SerializeValue(this BufferSerializer serializer, ref Health health) where TReaderWriter : IReaderWriter
+ {
+ // Because the BufferSerializer already knows how to read and write the primitive types
+ // We can use the existing BufferSerializer serialization.
+ serializer.SerializeValue(ref health.MaxHealth);
+ serializer.SerializeValue(ref health.CurrentHealth);
+ }
+ }
+ #endregion
+
+ internal class TestSerializationDocs
+ {
+ [Test]
+ public void TestFastBufferSerialization()
+ {
+ var healthToTest = new Health { MaxHealth = 123, CurrentHealth = 89 };
+ var expected = healthToTest;
+
+ using var writer = new FastBufferWriter(256, Allocator.Temp, int.MaxValue);
+ writer.WriteValueSafe(healthToTest);
+
+ using var reader = new FastBufferReader(writer, Allocator.None);
+ reader.ReadValueSafe(out Health readHealth);
+
+ Assert.AreEqual(expected.MaxHealth, readHealth.MaxHealth);
+ Assert.AreEqual(expected.CurrentHealth, readHealth.CurrentHealth);
+ }
+
+ [Test]
+ public void TestBufferSerializerSerialization()
+ {
+ var healthToTest = new Health { MaxHealth = 456, CurrentHealth = 78 };
+ var expected = healthToTest;
+
+ using var writer = new FastBufferWriter(256, Allocator.Temp, int.MaxValue);
+ var bufferWriter = new BufferSerializer(new BufferSerializerWriter(writer));
+ bufferWriter.SerializeValue(ref healthToTest);
+
+ using var tempReader = new FastBufferReader(bufferWriter.GetFastBufferWriter(), Allocator.None);
+ var bufferReader = new BufferSerializer(new BufferSerializerReader(tempReader));
+ var readHealth = new Health();
+ bufferReader.SerializeValue(ref readHealth);
+
+ Assert.AreEqual(expected.MaxHealth, readHealth.MaxHealth);
+ Assert.AreEqual(expected.CurrentHealth, readHealth.CurrentHealth);
+
+ }
+ }
+}
diff --git a/com.unity.netcode.gameobjects/Tests/Editor/DocumentationCodeSamples/Serialization/SerializationCustomization.cs.meta b/com.unity.netcode.gameobjects/Tests/Editor/DocumentationCodeSamples/Serialization/SerializationCustomization.cs.meta
new file mode 100644
index 0000000000..a39141e43d
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Tests/Editor/DocumentationCodeSamples/Serialization/SerializationCustomization.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 08949d7abc1249418192e44999279f89
+timeCreated: 1780101010
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Tests/Editor/InterpolatorTests.cs b/com.unity.netcode.gameobjects/Tests/Editor/InterpolatorTests.cs
index 666183abe6..a97c2272ed 100644
--- a/com.unity.netcode.gameobjects/Tests/Editor/InterpolatorTests.cs
+++ b/com.unity.netcode.gameobjects/Tests/Editor/InterpolatorTests.cs
@@ -301,5 +301,103 @@ public void TestDuplicatedValues()
Assert.That(interp, Is.EqualTo(2f));
// Since there is no extrapolation, the rest of this test was removed.
}
+
+ #region Lerp Smoothing
+
+ // Deliberately not round numbers, so exactly representable values cannot mask a defect.
+ private const double k_SmoothTickInterval = 1.0d / 30.0d;
+ private const int k_SmoothTickLatency = 2;
+ private const float k_SmoothStartValue = 3.17f;
+ private const float k_SmoothVelocity = 2.3f;
+ private const double k_SmoothMoveDuration = 1.53d;
+ private const double k_SmoothTotalDuration = 2.11d;
+
+ ///
+ /// Drives the lerp and smooth dampening interpolation path with lerp smoothing enabled, where an
+ /// authority moves at a constant velocity and then holds still while the non-authority renders at
+ /// .
+ ///
+ /// The interpolated value once has elapsed.
+ private float RunLerpSmoothing(float maximumInterpolationTime, float frameDeltaTime, bool lerp)
+ {
+ var interpolator = new BufferedLinearInterpolatorFloat
+ {
+ MaximumInterpolationTime = maximumInterpolationTime,
+ LerpSmoothEnabled = true,
+ };
+ interpolator.ResetTo(k_SmoothStartValue, 0.0d);
+
+ var restValue = k_SmoothStartValue + (float)(k_SmoothVelocity * k_SmoothMoveDuration);
+ var maxDeltaTime = k_SmoothTickLatency * k_SmoothTickInterval;
+ var nextTick = 1;
+ var currentValue = k_SmoothStartValue;
+
+ for (var time = 0.0d; time < k_SmoothTotalDuration; time += frameDeltaTime)
+ {
+ // Deliver every state update whose send time has already passed.
+ while (nextTick * k_SmoothTickInterval <= time)
+ {
+ var sentTime = nextTick * k_SmoothTickInterval;
+ var sentValue = sentTime <= k_SmoothMoveDuration
+ ? k_SmoothStartValue + (float)(k_SmoothVelocity * sentTime)
+ : restValue;
+ interpolator.AddMeasurement(sentValue, sentTime);
+ nextTick++;
+ }
+
+ currentValue = interpolator.Update(frameDeltaTime, time - maxDeltaTime, k_SmoothTickInterval, maxDeltaTime, lerp);
+ }
+
+ return currentValue;
+ }
+
+ ///
+ /// Lerp smoothing must still advance the value at 1.0f, the maximum legal value of the
+ /// family of fields.
+ ///
+ [Test]
+ public void LerpSmoothingDoesNotFreezeAtMaximumInterpolationTime([Values] bool lerp)
+ {
+ var result = RunLerpSmoothing(1.0f, 1.0f / 60.0f, lerp);
+
+ Assert.That(result, Is.GreaterThan(k_SmoothStartValue + 1.0f),
+ $"Interpolated value only advanced {result - k_SmoothStartValue} from {k_SmoothStartValue} over " +
+ $"{k_SmoothTotalDuration}s of authority motion. The maximum interpolation time froze the transform.");
+ }
+
+ ///
+ /// The rate at which lerp smoothing converges must not depend on the frame rate.
+ ///
+ [Test]
+ public void LerpSmoothingIsFrameRateIndependent()
+ {
+ // Heavier than the default, where the frame rate dependency is measurable.
+ const float maximumInterpolationTime = 0.87f;
+
+ var atThirtyFps = RunLerpSmoothing(maximumInterpolationTime, 1.0f / 30.0f, true);
+ var atTwoFortyFps = RunLerpSmoothing(maximumInterpolationTime, 1.0f / 240.0f, true);
+
+ Assert.That(atThirtyFps, Is.EqualTo(atTwoFortyFps).Within(0.01f),
+ $"The same elapsed time and interpolation settings produced {atThirtyFps} at 30fps but " +
+ $"{atTwoFortyFps} at 240fps. The smoothing rate is scaling with the frame rate.");
+ }
+
+ ///
+ /// Only 1.0f is substituted for, so settings below it keep their own smoothing rate and a heavier
+ /// setting stays smoother than a lighter one.
+ ///
+ [Test]
+ public void LerpSmoothingPreservesSettingsBelowTheMaximum()
+ {
+ // 0.99f is the retention substituted for 1.0f, so clamping to it would collapse these two.
+ var lighter = RunLerpSmoothing(0.99f, 1.0f / 60.0f, true);
+ var heavier = RunLerpSmoothing(0.995f, 1.0f / 60.0f, true);
+
+ Assert.That(heavier, Is.LessThan(lighter),
+ $"0.995 converged to {heavier} and 0.99 to {lighter} over the same motion. A higher maximum " +
+ "interpolation time has to retain more of the previous value, so it cannot converge first.");
+ }
+
+ #endregion
}
}
diff --git a/com.unity.netcode.gameobjects/Tests/Editor/Messaging/MessageReceivingTests.cs b/com.unity.netcode.gameobjects/Tests/Editor/Messaging/MessageReceivingTests.cs
index d77bf4ea72..4d3df172cf 100644
--- a/com.unity.netcode.gameobjects/Tests/Editor/Messaging/MessageReceivingTests.cs
+++ b/com.unity.netcode.gameobjects/Tests/Editor/Messaging/MessageReceivingTests.cs
@@ -1,9 +1,10 @@
using System;
using System.Collections.Generic;
using NUnit.Framework;
-using NUnit.Framework.Internal;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
+using UnityEngine.TestTools.Constraints;
+using Is = NUnit.Framework.Is;
namespace Unity.Netcode.EditorTests
{
@@ -95,22 +96,23 @@ public void WhenHandlingAMessage_ReceiveMethodIsCalled()
};
var message = GetMessage();
- var writer = new FastBufferWriter(1300, Allocator.Temp);
- using (writer)
- {
- writer.TryBeginWrite(FastBufferWriter.GetWriteSize(message));
- writer.WriteValue(message);
+ using var writer = new FastBufferWriter(1300, Allocator.Temp);
+ writer.TryBeginWrite(FastBufferWriter.GetWriteSize(message));
+ writer.WriteValue(message);
- var reader = new FastBufferReader(writer, Allocator.Temp);
- using (reader)
- {
- m_MessageManager.HandleMessage(messageHeader, reader, 0, 0, 0);
- Assert.IsTrue(TestMessage.Deserialized);
- Assert.IsTrue(TestMessage.Handled);
- Assert.AreEqual(1, TestMessage.DeserializedValues.Count);
- Assert.AreEqual(message, TestMessage.DeserializedValues[0]);
- }
- }
+ using var reader = new FastBufferReader(writer, Allocator.Temp);
+ m_MessageManager.HandleMessage(messageHeader, reader, 0, 0, 0);
+ Assert.IsTrue(TestMessage.Deserialized);
+ Assert.IsTrue(TestMessage.Handled);
+ Assert.AreEqual(1, TestMessage.DeserializedValues.Count);
+ Assert.AreEqual(message, TestMessage.DeserializedValues[0]);
+
+ // Check for GC Allocations
+ Assert.That(() =>
+ {
+ reader.Seek(0);
+ m_MessageManager.HandleMessage(messageHeader, reader, 0, 0, 0);
+ }, Is.Not.AllocatingGCMemory());
}
[Test]
@@ -220,44 +222,45 @@ public unsafe void WhenReceivingMultipleMessagesAndProcessingMessageQueue_Receiv
var message = GetMessage();
var message2 = GetMessage();
- var writer = new FastBufferWriter(1300, Allocator.Temp);
- using (writer)
+ using var writer = new FastBufferWriter(1300, Allocator.Temp);
+ writer.WriteValueSafe(batchHeader);
+ BytePacker.WriteValueBitPacked(writer, messageHeader.MessageType);
+ BytePacker.WriteValueBitPacked(writer, messageHeader.MessageSize);
+ writer.WriteValueSafe(message);
+ BytePacker.WriteValueBitPacked(writer, messageHeader.MessageType);
+ BytePacker.WriteValueBitPacked(writer, messageHeader.MessageSize);
+ writer.WriteValueSafe(message2);
+
+ // Fill out the rest of the batch header
+ writer.Seek(0);
+ batchHeader = new NetworkBatchHeader
{
- writer.WriteValueSafe(batchHeader);
- BytePacker.WriteValueBitPacked(writer, messageHeader.MessageType);
- BytePacker.WriteValueBitPacked(writer, messageHeader.MessageSize);
- writer.WriteValueSafe(message);
- BytePacker.WriteValueBitPacked(writer, messageHeader.MessageType);
- BytePacker.WriteValueBitPacked(writer, messageHeader.MessageSize);
- writer.WriteValueSafe(message2);
+ Magic = NetworkBatchHeader.MagicValue,
+ BatchSize = writer.Length,
+ BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(NetworkBatchHeader), writer.Length - sizeof(NetworkBatchHeader)),
+ BatchCount = 2
+ };
+ writer.WriteValue(batchHeader);
- // Fill out the rest of the batch header
- writer.Seek(0);
- batchHeader = new NetworkBatchHeader
- {
- Magic = NetworkBatchHeader.MagicValue,
- BatchSize = writer.Length,
- BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(NetworkBatchHeader), writer.Length - sizeof(NetworkBatchHeader)),
- BatchCount = 2
- };
- writer.WriteValue(batchHeader);
+ var data = new ArraySegment(writer.ToArray());
+ m_MessageManager.HandleIncomingData(0, data, 0);
+ Assert.IsFalse(TestMessage.Deserialized);
+ Assert.IsFalse(TestMessage.Handled);
+ Assert.IsEmpty(TestMessage.DeserializedValues);
- var reader = new FastBufferReader(writer, Allocator.Temp);
- using (reader)
- {
- m_MessageManager.HandleIncomingData(0, new ArraySegment(writer.ToArray()), 0);
- Assert.IsFalse(TestMessage.Deserialized);
- Assert.IsFalse(TestMessage.Handled);
- Assert.IsEmpty(TestMessage.DeserializedValues);
+ m_MessageManager.ProcessIncomingMessageQueue();
+ Assert.IsTrue(TestMessage.Deserialized);
+ Assert.IsTrue(TestMessage.Handled);
+ Assert.AreEqual(2, TestMessage.DeserializedValues.Count);
+ Assert.AreEqual(message, TestMessage.DeserializedValues[0]);
+ Assert.AreEqual(message2, TestMessage.DeserializedValues[1]);
- m_MessageManager.ProcessIncomingMessageQueue();
- Assert.IsTrue(TestMessage.Deserialized);
- Assert.IsTrue(TestMessage.Handled);
- Assert.AreEqual(2, TestMessage.DeserializedValues.Count);
- Assert.AreEqual(message, TestMessage.DeserializedValues[0]);
- Assert.AreEqual(message2, TestMessage.DeserializedValues[1]);
- }
- }
+ // Check for GC Allocations
+ Assert.That(() =>
+ {
+ m_MessageManager.HandleIncomingData(0, data, 0);
+ m_MessageManager.ProcessIncomingMessageQueue();
+ }, Is.Not.AllocatingGCMemory());
}
}
}
diff --git a/com.unity.netcode.gameobjects/Tests/Editor/NetworkDeltaPositionTests.cs b/com.unity.netcode.gameobjects/Tests/Editor/NetworkDeltaPositionTests.cs
new file mode 100644
index 0000000000..c93832d030
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Tests/Editor/NetworkDeltaPositionTests.cs
@@ -0,0 +1,371 @@
+using NUnit.Framework;
+using Unity.Collections;
+using Unity.Mathematics;
+using Unity.Netcode.Components;
+using UnityEngine;
+
+namespace Unity.Netcode.EditorTests
+{
+ ///
+ /// Branch coverage for 's encoding math.
+ ///
+ internal class NetworkDeltaPositionTests
+ {
+ private const int k_Tick = 100;
+
+ // Lossy as a half float, and two of them still fit under the collapse threshold.
+ private const float k_LossyStep = 0.7f;
+
+ // Past the threshold and exactly representable, so the collapse cannot hinge on rounding.
+ private const float k_CollapsingStep = NetworkDeltaPosition.MaxDeltaBeforeAdjustment + 0.5f;
+
+ // Off the half float lattice on every axis, so each conversion leaves rounding loss behind.
+ private static readonly Vector3 k_Base = new Vector3(30.0007f, -12.0003f, 5.0009f);
+
+ private static Vector3 Offset(float amount)
+ {
+ return k_Base + new Vector3(amount, amount, amount);
+ }
+
+ // The transmitted form, so comparisons are against what actually goes on the wire.
+ private static ushort[] Encoded(NetworkDeltaPosition deltaPosition)
+ {
+ return new[]
+ {
+ deltaPosition.HalfVector3.Axis.x.value,
+ deltaPosition.HalfVector3.Axis.y.value,
+ deltaPosition.HalfVector3.Axis.z.value,
+ };
+ }
+
+ [Test]
+ public void ConstructorOverloadsProduceTheSameInitialState()
+ {
+ var position = k_Base;
+ var allAxes = math.bool3(true);
+
+ var instances = new[]
+ {
+ new NetworkDeltaPosition(position, k_Tick),
+ new NetworkDeltaPosition(position, k_Tick, allAxes),
+ new NetworkDeltaPosition(position.x, position.y, position.z, k_Tick),
+ new NetworkDeltaPosition(position.x, position.y, position.z, k_Tick, allAxes),
+ };
+
+ foreach (var instance in instances)
+ {
+ Assert.AreEqual(position, instance.GetCurrentBasePosition(), "The base position should be where the object started.");
+ Assert.AreEqual(Vector3.zero, instance.GetDeltaPosition(), "Nothing has moved yet, so there is no delta.");
+ Assert.AreEqual(Vector3.zero, instance.PrecisionLossDelta, "No conversion has lost anything yet.");
+ Assert.AreEqual(k_Tick, instance.NetworkTick, "The construction tick should be recorded.");
+ Assert.IsFalse(instance.CollapsedDeltaIntoBase, "A zero delta cannot have collapsed.");
+ Assert.IsFalse(instance.SynchronizeBase, "The base is only synchronized explicitly.");
+ Assert.AreEqual(allAxes, instance.HalfVector3.AxisToSynchronize, "All axes should be synchronized by default.");
+ }
+ }
+
+ [Test]
+ public void AccessorsReportTheUnderlyingState()
+ {
+ var deltaPosition = new NetworkDeltaPosition(k_Base, k_Tick);
+ var moved = Offset(k_LossyStep);
+ deltaPosition.UpdateFrom(ref moved, k_Tick + 1);
+
+ Assert.AreEqual(deltaPosition.CurrentBasePosition, deltaPosition.GetCurrentBasePosition());
+ Assert.AreEqual(deltaPosition.DeltaPosition, deltaPosition.GetDeltaPosition());
+ Assert.AreEqual(deltaPosition.HalfDeltaConvertedBack, deltaPosition.GetConvertedDelta());
+ Assert.AreEqual(deltaPosition.CurrentBasePosition + deltaPosition.DeltaPosition, deltaPosition.GetFullPosition());
+
+ Assert.AreNotEqual(deltaPosition.GetDeltaPosition().x, deltaPosition.GetConvertedDelta().x,
+ "The converted delta is the lossy one and should not match the full precision delta.");
+ }
+
+ [Test]
+ public void MovingFoldsThePreviousRoundingLossBackIn()
+ {
+ var deltaPosition = new NetworkDeltaPosition(k_Base, k_Tick);
+
+ var firstMove = Offset(k_LossyStep);
+ deltaPosition.UpdateFrom(ref firstMove, k_Tick + 1);
+
+ var carriedLoss = deltaPosition.PrecisionLossDelta;
+ Assert.AreNotEqual(0.0f, carriedLoss.x, "A step off the lattice has to leave rounding loss behind.");
+
+ var basePosition = deltaPosition.GetCurrentBasePosition();
+ var secondMove = Offset(k_LossyStep * 2.0f);
+ deltaPosition.UpdateFrom(ref secondMove, k_Tick + 2);
+
+ Assert.IsFalse(deltaPosition.CollapsedDeltaIntoBase,
+ "Both steps together have to stay under the collapse threshold, or the delta asserted on below is reset to zero.");
+
+ // Folding the loss in is what keeps the average position accurate instead of drifting by a
+ // fraction of a step per send.
+ var rawDelta = secondMove.x - basePosition.x;
+ Assert.AreEqual(rawDelta + carriedLoss.x, deltaPosition.GetDeltaPosition().x, 1e-7f,
+ "The delta being sent should have the carried rounding loss added to it.");
+ Assert.AreNotEqual(math.half(rawDelta).value, deltaPosition.HalfVector3.Axis.x.value,
+ "Folding the loss in has to change the transmitted value, or it would have no effect.");
+ Assert.AreNotEqual(carriedLoss.x, deltaPosition.PrecisionLossDelta.x,
+ "The carried loss should be recomputed from the conversion that just happened.");
+ }
+
+ [Test]
+ public void StandingStillDoesNotChangeWhatIsSent()
+ {
+ var deltaPosition = new NetworkDeltaPosition(k_Base, k_Tick);
+
+ // Arrive off the lattice, which is where a settling object ends up.
+ var arrived = Offset(k_LossyStep);
+ deltaPosition.UpdateFrom(ref arrived, k_Tick + 1);
+
+ var encodedOnArrival = Encoded(deltaPosition);
+ var lossOnArrival = deltaPosition.PrecisionLossDelta;
+ Assert.AreNotEqual(0.0f, lossOnArrival.x, "The arrival conversion has to leave rounding loss behind.");
+
+ var currentTick = k_Tick + 2;
+ var maxTick = k_Tick + 5;
+
+ // Folding the loss back in while stationary is what made resting objects jitter.
+ while (currentTick <= maxTick)
+ {
+ deltaPosition.UpdateFrom(ref arrived, currentTick);
+
+ Assert.AreEqual(encodedOnArrival, Encoded(deltaPosition),
+ $"The transmitted delta changed on tick {currentTick} while the position did not move.");
+ Assert.AreEqual(lossOnArrival, deltaPosition.PrecisionLossDelta,
+ $"The carried loss should be untouched on tick {currentTick} so it still applies once movement resumes.");
+ currentTick++;
+ }
+ }
+
+ [Test]
+ public void DeltaCollapsesIntoTheBaseAtTheThreshold()
+ {
+ var deltaPosition = new NetworkDeltaPosition(k_Base, k_Tick);
+ var originalBase = deltaPosition.GetCurrentBasePosition();
+
+ var moved = Offset(k_CollapsingStep);
+ deltaPosition.UpdateFrom(ref moved, k_Tick + 1);
+
+ Assert.IsTrue(deltaPosition.CollapsedDeltaIntoBase, "A delta at the threshold should have been folded into the base.");
+ Assert.AreEqual(0.0f, deltaPosition.GetDeltaPosition().x, "The delta should be reset once it is folded in.");
+ Assert.AreEqual(0.0f, deltaPosition.GetConvertedDelta().x, "The converted delta should be reset along with it.");
+ Assert.AreNotEqual(originalBase.x, deltaPosition.GetCurrentBasePosition().x, "The base should have absorbed the delta.");
+ Assert.AreEqual(moved.x, deltaPosition.GetFullPosition().x, 1e-3f,
+ "Folding the delta into the base must not move the object it describes.");
+ }
+
+ [Test]
+ public void UnsynchronizedAxesAreLeftUntouched()
+ {
+ var deltaPosition = new NetworkDeltaPosition(k_Base, k_Tick, math.bool3(true, false, false));
+
+ var moved = Offset(k_LossyStep);
+ deltaPosition.UpdateFrom(ref moved, k_Tick + 1);
+
+ Assert.AreNotEqual(0.0f, deltaPosition.GetDeltaPosition().x, "The synchronized axis should track the movement.");
+ Assert.AreEqual(0.0f, deltaPosition.GetDeltaPosition().y, "An unsynchronized axis should not produce a delta.");
+ Assert.AreEqual(0.0f, deltaPosition.GetDeltaPosition().z, "An unsynchronized axis should not produce a delta.");
+
+ // A stale reference here would break the comparison if the axis is synchronized later.
+ Assert.AreEqual(moved.x, deltaPosition.PreviousPosition.x, "The synchronized axis should record where it was sent from.");
+ Assert.AreEqual(k_Base.y, deltaPosition.PreviousPosition.y, "An unsynchronized axis should keep its original reference.");
+ Assert.AreEqual(k_Base.z, deltaPosition.PreviousPosition.z, "An unsynchronized axis should keep its original reference.");
+ }
+
+ [Test]
+ public void DecodingOnTheSameTickDoesNotReadTheEncodedAxes()
+ {
+ var deltaPosition = new NetworkDeltaPosition(k_Base, k_Tick);
+ var moved = Offset(k_LossyStep);
+ deltaPosition.UpdateFrom(ref moved, k_Tick + 1);
+
+ var expected = deltaPosition.GetFullPosition();
+
+ // Overwriting the encoded axes proves this path returns the already-decoded value rather than
+ // decoding again, which would apply the same delta twice.
+ deltaPosition.HalfVector3.Axis = math.half3(new float3(1.9f, 1.9f, 1.9f));
+
+ Assert.AreEqual(expected, deltaPosition.ToVector3(k_Tick + 1),
+ "Decoding the tick that was just written should return the position already held.");
+ }
+
+ [Test]
+ public void DecodingANewTickAppliesTheDelta()
+ {
+ var authority = new NetworkDeltaPosition(k_Base, k_Tick);
+ var moved = Offset(k_LossyStep);
+ authority.UpdateFrom(ref moved, k_Tick + 1);
+
+ var receiver = new NetworkDeltaPosition(k_Base, k_Tick)
+ {
+ HalfVector3 = authority.HalfVector3,
+ };
+
+ var decoded = receiver.ToVector3(k_Tick + 1);
+
+ Assert.AreEqual(authority.GetConvertedDelta().x, receiver.GetDeltaPosition().x,
+ "The receiver should decode the same delta the authority encoded.");
+ Assert.AreEqual(k_Base.x + authority.GetConvertedDelta().x, decoded.x, 1e-4f,
+ "The decoded position should be the base plus the transmitted delta.");
+ }
+
+ [Test]
+ public void DecodingCollapsesIntoTheBaseAtTheThreshold()
+ {
+ var authority = new NetworkDeltaPosition(k_Base, k_Tick);
+ var moved = Offset(k_CollapsingStep);
+ authority.UpdateFrom(ref moved, k_Tick + 1);
+
+ // The send side folds the delta into its own base but leaves the encoded axes holding it, so the
+ // receiving side has to perform the same fold to end up on the same base.
+ var receiver = new NetworkDeltaPosition(k_Base, k_Tick)
+ {
+ HalfVector3 = authority.HalfVector3,
+ };
+
+ var decoded = receiver.ToVector3(k_Tick + 1);
+
+ Assert.AreEqual(0.0f, receiver.GetDeltaPosition().x, "The delta should be reset once it is folded into the base.");
+ Assert.AreEqual(0, receiver.HalfVector3.Axis.x.value, "The encoded axis should be cleared along with it.");
+ Assert.AreEqual(authority.GetCurrentBasePosition().x, receiver.GetCurrentBasePosition().x, 1e-4f,
+ "Both sides must end up on the same base position or they will disagree from here on.");
+ Assert.AreEqual(moved.x, decoded.x, 1e-3f, "Folding the delta into the base must not move the object.");
+ }
+
+ [Test]
+ public void DecodingIgnoresUnsynchronizedAxes()
+ {
+ var axesToSynchronize = math.bool3(true, false, false);
+ var authority = new NetworkDeltaPosition(k_Base, k_Tick, axesToSynchronize);
+ var moved = Offset(k_LossyStep);
+ authority.UpdateFrom(ref moved, k_Tick + 1);
+
+ var receiver = new NetworkDeltaPosition(k_Base, k_Tick, axesToSynchronize)
+ {
+ HalfVector3 = authority.HalfVector3,
+ };
+
+ var decoded = receiver.ToVector3(k_Tick + 1);
+
+ Assert.AreNotEqual(k_Base.x, decoded.x, "The synchronized axis should have moved.");
+ Assert.AreEqual(k_Base.y, decoded.y, "An unsynchronized axis should stay at the base value.");
+ Assert.AreEqual(k_Base.z, decoded.z, "An unsynchronized axis should stay at the base value.");
+ }
+
+ [Test]
+ public void HalfDeltaRoundTripsWhenTheBaseIsNotSynchronized()
+ {
+ var source = new NetworkDeltaPosition(k_Base, k_Tick);
+ var moved = Offset(k_LossyStep);
+ source.UpdateFrom(ref moved, k_Tick + 1);
+
+ var result = RoundTrip(source, synchronizeBase: false);
+
+ Assert.AreEqual(Encoded(source), Encoded(result), "The encoded axes should survive the round trip.");
+
+ // Only the half float axes go on the wire here, so the receiver keeps whatever base it had.
+ Assert.AreEqual(Vector3.zero, result.GetCurrentBasePosition(), "The base should not be transmitted in this mode.");
+ }
+
+ [Test]
+ public void FullPrecisionRoundTripsWhenTheBaseIsSynchronized()
+ {
+ var source = new NetworkDeltaPosition(k_Base, k_Tick);
+ var moved = Offset(k_LossyStep);
+ source.UpdateFrom(ref moved, k_Tick + 1);
+
+ var result = RoundTrip(source, synchronizeBase: true);
+
+ // Synchronizing sends both values at full precision, so this path has to be lossless.
+ Assert.AreEqual(source.GetDeltaPosition(), result.GetDeltaPosition(), "The delta should round trip exactly.");
+ Assert.AreEqual(source.GetCurrentBasePosition(), result.GetCurrentBasePosition(), "The base should round trip exactly.");
+ }
+
+ [Test]
+ public void QuantumIsTheSmallestChangeTheEncodingCanSee()
+ {
+ // Exactly representable, so "one step away" is unambiguous.
+ var values = new[] { 0.5f, 1.0f, -1.0f, 2.0f, 300.0f, 1024.0f };
+
+ foreach (var value in values)
+ {
+ var quantum = NetworkDeltaPosition.HalfPrecisionQuantum(value);
+ Assert.Greater(quantum, 0.0f, $"The step size at {value} should be positive.");
+
+ Assert.AreNotEqual(math.half(value).value, math.half(value + quantum).value,
+ $"A full step from {value} should encode differently, or it is not the step size.");
+ Assert.AreEqual(math.half(value).value, math.half(value + (quantum * 0.25f)).value,
+ $"A quarter step from {value} should encode identically, or the step size is too large.");
+
+ // The lattice is symmetric about zero, which is why the sign is dropped.
+ Assert.AreEqual(quantum, NetworkDeltaPosition.HalfPrecisionQuantum(-value),
+ $"The step size at {value} and {-value} should be the same.");
+ }
+ }
+
+ [Test]
+ public void QuantumIsGuardedAtTheTopOfTheRange()
+ {
+ // 70000f is the finite one: the conversion itself rounds to infinity, which reaches the guard
+ // by a different path than handing it an infinity outright.
+ var values = new[]
+ {
+ 65504.0f, -65504.0f, 70000.0f,
+ float.PositiveInfinity, float.NegativeInfinity, float.NaN,
+ };
+
+ foreach (var value in values)
+ {
+ Assert.AreEqual(NetworkDeltaPosition.MaxDeltaBeforeAdjustment,
+ NetworkDeltaPosition.HalfPrecisionQuantum(value),
+ $"{value} is at or past the largest finite half float and should fall back to the maximum delta.");
+ }
+ }
+
+ [Test]
+ public void QuantumIsNeverNonFiniteOrZero()
+ {
+ // Why the guard exists: an infinite step size would make the "has it moved?" comparison in
+ // UpdateFrom false for every input, silently stopping the rounding loss from being applied.
+ var unguarded = Mathf.HalfToFloat(0x7BFF + 1) - Mathf.HalfToFloat(0x7BFF);
+ Assert.IsTrue(float.IsInfinity(unguarded) || float.IsNaN(unguarded),
+ "The unguarded computation at the top of the range should be non-finite, which is why the guard exists.");
+
+ var values = new[]
+ {
+ 0.0f, float.Epsilon, 1e-7f, 0.5f, 1.0f, 100.0f, 65503.0f, 65504.0f, -65504.0f, 70000.0f,
+ float.PositiveInfinity, float.NegativeInfinity, float.NaN,
+ };
+
+ foreach (var value in values)
+ {
+ var quantum = NetworkDeltaPosition.HalfPrecisionQuantum(value);
+ Assert.IsFalse(float.IsNaN(quantum) || float.IsInfinity(quantum), $"The step size at {value} should be finite.");
+ Assert.Greater(quantum, 0.0f, $"The step size at {value} should be positive.");
+ }
+ }
+
+ private static NetworkDeltaPosition RoundTrip(NetworkDeltaPosition source, bool synchronizeBase)
+ {
+ source.SynchronizeBase = synchronizeBase;
+
+ using var writer = new FastBufferWriter(256, Allocator.Temp);
+ var writeSerializer = new BufferSerializer(new BufferSerializerWriter(writer));
+ source.NetworkSerialize(writeSerializer);
+
+ // Starts from a different state, so a value that failed to arrive shows up as a mismatch.
+ var result = new NetworkDeltaPosition(Vector3.zero, 0)
+ {
+ SynchronizeBase = synchronizeBase,
+ HalfVector3 = { AxisToSynchronize = source.HalfVector3.AxisToSynchronize },
+ };
+
+ using var reader = new FastBufferReader(writer, Allocator.Temp);
+ var readSerializer = new BufferSerializer(new BufferSerializerReader(reader));
+ result.NetworkSerialize(readSerializer);
+
+ return result;
+ }
+ }
+}
diff --git a/com.unity.netcode.gameobjects/Tests/Editor/NetworkDeltaPositionTests.cs.meta b/com.unity.netcode.gameobjects/Tests/Editor/NetworkDeltaPositionTests.cs.meta
new file mode 100644
index 0000000000..8ef2b73daf
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Tests/Editor/NetworkDeltaPositionTests.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4c273f2393c37e64980677d134606e15
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Tests/Editor/Serialization/BytePackerTests.cs b/com.unity.netcode.gameobjects/Tests/Editor/Serialization/BytePackerTests.cs
index 1bd197997f..8c1be03140 100644
--- a/com.unity.netcode.gameobjects/Tests/Editor/Serialization/BytePackerTests.cs
+++ b/com.unity.netcode.gameobjects/Tests/Editor/Serialization/BytePackerTests.cs
@@ -92,7 +92,7 @@ private unsafe void RunTypeTest(T value) where T : unmanaged
using (reader)
{
- var outVal = new T();
+ var outVal = default(T);
MethodInfo method;
if (value is Enum)
{
diff --git a/com.unity.netcode.gameobjects/Tests/Editor/Serialization/FastBufferReaderTests.cs b/com.unity.netcode.gameobjects/Tests/Editor/Serialization/FastBufferReaderTests.cs
index 85aabbb52e..d63b7bb067 100644
--- a/com.unity.netcode.gameobjects/Tests/Editor/Serialization/FastBufferReaderTests.cs
+++ b/com.unity.netcode.gameobjects/Tests/Editor/Serialization/FastBufferReaderTests.cs
@@ -259,7 +259,7 @@ private void RunReadMethod(string methodName, FastBufferReader reader, out T
}
}
}
- value = new T();
+ value = default;
Assert.NotNull(method);
@@ -766,8 +766,7 @@ public unsafe void RunFixedStringTest(T fixedStringValue, int numBytesWritten
{
VerifyPositionAndLength(reader, writer.Length);
- var result = new T();
- reader.ReadValueSafe(out result);
+ reader.ReadValueSafe(out T result);
Assert.AreEqual(fixedStringValue, result);
VerifyCheckBytes(reader, serializedValueSize);
@@ -924,6 +923,50 @@ public void GivenFastBufferWriterContainingValue_WhenReadingString_ValueMatchesW
}
}
+ ///
+ /// This validates that catches a potential
+ /// scenario where the string's character count value has already been read
+ /// due to an error within user script and the resultant character count
+ /// multiplied times 2 (when using 2 bytes vs 1) causes the length to roll over
+ /// to a negative value which, in turn, causes the reader to attempt to read
+ /// into restricted memory and causes the editor to crash.
+ ///
+ [Test]
+ public void ReadingStringAfterStringLengthHasAlreadyBeenRead([Values] bool isSafeRead)
+ {
+ // This was an issue uncovered in UUM-145752 that resulted
+ // in the below text to result in a length that when using
+ // 2 bytes per character would cause the skewed size to roll
+ // over into a negative value causing the editor to crash
+ // when it attempted to read a large negative offset value.
+ string valueToTest = "true";
+
+ var serializedValueSize = FastBufferWriter.GetWriteSize(valueToTest);
+
+ using var writer = new FastBufferWriter(serializedValueSize, Allocator.Temp);
+ writer.WriteValueSafe(valueToTest);
+
+ using var reader = new FastBufferReader(writer, Allocator.Temp);
+
+ // Read the value of the character count before trying to read the string
+ // This mocks user code having read too far into a stream causing the position to be skewed such that
+ // the string reader reads the some of the bytes for the actual text as the length.
+ reader.ReadByteSafe(out byte count);
+ Assert.True(count == valueToTest.Length, $"Count ({count}) is not the expected size of {valueToTest.Length}!");
+ if (isSafeRead)
+ {
+ // This should throw an overflow exception but should not crash the editor.
+ Assert.Throws(() => reader.ReadValueSafe(out string valueRead));
+ }
+ else
+ {
+ // Assume user does a pre-calculation of the size to be read:
+ Assert.IsTrue(reader.TryBeginRead(count), "Reader denied read permission");
+
+ // This should throw an overflow exception but should not crash the editor.
+ Assert.Throws(() => reader.ReadValue(out string valueRead));
+ }
+ }
[TestCase(1, 0)]
[TestCase(2, 0)]
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/Components/BufferDataValidationComponent.cs b/com.unity.netcode.gameobjects/Tests/Runtime/Components/BufferDataValidationComponent.cs
index 3e46ec4b9e..d427251afe 100644
--- a/com.unity.netcode.gameobjects/Tests/Runtime/Components/BufferDataValidationComponent.cs
+++ b/com.unity.netcode.gameobjects/Tests/Runtime/Components/BufferDataValidationComponent.cs
@@ -38,8 +38,7 @@ internal class BufferDataValidationComponent : NetworkBehaviour
private List m_SendBuffer;
private List m_PreCalculatedBufferValues;
- // Start is called before the first frame update
- private void Start()
+ protected override void OnNetworkPreSpawn(ref NetworkManager networkManager)
{
m_WaitForValidation = false;
m_CurrentBufferSize = BufferSizeStart;
@@ -49,6 +48,7 @@ private void Start()
{
m_PreCalculatedBufferValues.Add((byte)Random.Range(0, 255));
}
+ base.OnNetworkPreSpawn(ref networkManager);
}
///
@@ -67,7 +67,12 @@ public bool IsTestComplete()
// Update is called once per frame
private void Update()
{
- if (NetworkManager.Singleton.IsListening && EnableTesting && !IsTestComplete() && !m_WaitForValidation)
+ if (!EnableTesting || !IsSpawned)
+ {
+ return;
+ }
+
+ if (!m_WaitForValidation && !IsTestComplete())
{
m_SendBuffer.Clear();
//Keep the current contents of the bufffer and fill the buffer with the delta difference of the buffer's current size and new size from the m_PreCalculatedBufferValues
@@ -77,16 +82,16 @@ private void Update()
m_WaitForValidation = true;
//Send the buffer
- SendBufferServerRpc(m_SendBuffer.ToArray());
+ SendBufferRpc(m_SendBuffer.ToArray());
}
+
}
///
- /// Server side RPC for testing
+ /// Sends to self for buffer queue testing
///
- /// server rpc parameters
- [ServerRpc]
- private void SendBufferServerRpc(byte[] buffer)
+ [Rpc(SendTo.Me)]
+ private void SendBufferRpc(byte[] buffer)
{
TestFailed = !NetworkManagerHelper.BuffersMatch(0, buffer.Length, buffer, m_SendBuffer.ToArray());
if (!TestFailed)
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/Components/NetworkVariableTestComponent.cs b/com.unity.netcode.gameobjects/Tests/Runtime/Components/NetworkVariableTestComponent.cs
index 3e77d9762b..616c9f03d4 100644
--- a/com.unity.netcode.gameobjects/Tests/Runtime/Components/NetworkVariableTestComponent.cs
+++ b/com.unity.netcode.gameobjects/Tests/Runtime/Components/NetworkVariableTestComponent.cs
@@ -242,7 +242,7 @@ internal class NetworkVariableTestComponent : NetworkBehaviour
private float m_WaitForChangesTimeout;
// Start is called before the first frame update
- private void InitializeTest()
+ public void InitializeTest()
{
// Generic Constructor Test Coverage
m_NetworkVariableBool = new NetworkVariable();
@@ -356,11 +356,6 @@ public bool IsTestComplete()
return m_FinishedTests;
}
- public void Awake()
- {
- InitializeTest();
- }
-
public void AssertAllValuesAreCorrect()
{
Assert.AreEqual(false, m_NetworkVariableBool.Value);
@@ -423,56 +418,52 @@ public void AssertAllValuesAreCorrect()
// Update is called once per frame
private void Update()
{
- if (EnableTesting)
+ if (!EnableTesting || !IsSpawned)
{
- //Added timeout functionality for near future changes to NetworkVariables
- if (!m_FinishedTests && m_ChangesAppliedToNetworkVariables)
- {
- //We finish testing if all NetworkVariables changed their value or we timed out waiting for
- //all NetworkVariables to change their value
- m_FinishedTests = DidAllValuesChange() || (m_WaitForChangesTimeout < Time.realtimeSinceStartup);
- }
- else
+ return;
+ }
+
+ if (!m_ChangesAppliedToNetworkVariables)
+ {
+ //Now change all of the values to make sure we are at least testing the local callback
+ m_NetworkVariableBool.Value = false;
+ m_NetworkVariableByte.Value = 255;
+ m_NetworkVariableColor.Value = new Color(100, 100, 100);
+ m_NetworkVariableColor32.Value = new Color32(100, 100, 100, 100);
+ m_NetworkVariableDouble.Value = 1000;
+ m_NetworkVariableFloat.Value = 1000.0f;
+ m_NetworkVariableInt.Value = 1000;
+ m_NetworkVariableLong.Value = 100000;
+ m_NetworkVariableSByte.Value = -127;
+ m_NetworkVariableQuaternion.Value = new Quaternion(100, 100, 100, 100);
+ m_NetworkVariablePose.Value = new Pose(new Vector3(100, 100, 100), new Quaternion(100, 100, 100, 100));
+ m_NetworkVariableShort.Value = short.MaxValue;
+ m_NetworkVariableVector4.Value = new Vector4(1000, 1000, 1000, 1000);
+ m_NetworkVariableVector3.Value = new Vector3(1000, 1000, 1000);
+ m_NetworkVariableVector2.Value = new Vector2(1000, 1000);
+ m_NetworkVariableRay.Value = new Ray(Vector3.one, Vector3.right);
+ m_NetworkVariableULong.Value = ulong.MaxValue;
+ m_NetworkVariableUInt.Value = uint.MaxValue;
+ m_NetworkVariableUShort.Value = ushort.MaxValue;
+ m_NetworkVariableFixedString32.Value = new FixedString32Bytes("FixedString32Bytes");
+ m_NetworkVariableFixedString64.Value = new FixedString64Bytes("FixedString64Bytes");
+ m_NetworkVariableFixedString128.Value = new FixedString128Bytes("FixedString128Bytes");
+ m_NetworkVariableFixedString512.Value = new FixedString512Bytes("FixedString512Bytes");
+ m_NetworkVariableFixedString4096.Value = new FixedString4096Bytes("FixedString4096Bytes");
+ m_NetworkVariableManaged.Value = new ManagedNetworkSerializableType
{
- if (NetworkManager != null && NetworkManager.IsListening)
- {
- //Now change all of the values to make sure we are at least testing the local callback
- m_NetworkVariableBool.Value = false;
- m_NetworkVariableByte.Value = 255;
- m_NetworkVariableColor.Value = new Color(100, 100, 100);
- m_NetworkVariableColor32.Value = new Color32(100, 100, 100, 100);
- m_NetworkVariableDouble.Value = 1000;
- m_NetworkVariableFloat.Value = 1000.0f;
- m_NetworkVariableInt.Value = 1000;
- m_NetworkVariableLong.Value = 100000;
- m_NetworkVariableSByte.Value = -127;
- m_NetworkVariableQuaternion.Value = new Quaternion(100, 100, 100, 100);
- m_NetworkVariablePose.Value = new Pose(new Vector3(100, 100, 100), new Quaternion(100, 100, 100, 100));
- m_NetworkVariableShort.Value = short.MaxValue;
- m_NetworkVariableVector4.Value = new Vector4(1000, 1000, 1000, 1000);
- m_NetworkVariableVector3.Value = new Vector3(1000, 1000, 1000);
- m_NetworkVariableVector2.Value = new Vector2(1000, 1000);
- m_NetworkVariableRay.Value = new Ray(Vector3.one, Vector3.right);
- m_NetworkVariableULong.Value = ulong.MaxValue;
- m_NetworkVariableUInt.Value = uint.MaxValue;
- m_NetworkVariableUShort.Value = ushort.MaxValue;
- m_NetworkVariableFixedString32.Value = new FixedString32Bytes("FixedString32Bytes");
- m_NetworkVariableFixedString64.Value = new FixedString64Bytes("FixedString64Bytes");
- m_NetworkVariableFixedString128.Value = new FixedString128Bytes("FixedString128Bytes");
- m_NetworkVariableFixedString512.Value = new FixedString512Bytes("FixedString512Bytes");
- m_NetworkVariableFixedString4096.Value = new FixedString4096Bytes("FixedString4096Bytes");
- m_NetworkVariableManaged.Value = new ManagedNetworkSerializableType
- {
- Str = "ManagedNetworkSerializableType",
- Ints = new[] { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000 },
- Embedded = new EmbeddedManagedNetworkSerializableType { Int = 20000 }
- };
-
- //Set the timeout (i.e. how long we will wait for all NetworkVariables to have registered their changes)
- m_WaitForChangesTimeout = Time.realtimeSinceStartup + 0.50f;
- m_ChangesAppliedToNetworkVariables = true;
- }
- }
+ Str = "ManagedNetworkSerializableType",
+ Ints = new[] { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000 },
+ Embedded = new EmbeddedManagedNetworkSerializableType { Int = 20000 }
+ };
+
+ //Set the timeout (i.e. how long we will wait for all NetworkVariables to have registered their changes)
+ m_WaitForChangesTimeout = Time.realtimeSinceStartup + 0.50f;
+ m_ChangesAppliedToNetworkVariables = true;
+ }
+ else if (!m_FinishedTests)
+ {
+ m_FinishedTests = DidAllValuesChange() || (m_WaitForChangesTimeout < Time.realtimeSinceStartup);
}
}
}
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/Connection/ConnectionApproval.cs b/com.unity.netcode.gameobjects/Tests/Runtime/Connection/ConnectionApproval.cs
index 2e0c81b690..56231899d4 100644
--- a/com.unity.netcode.gameobjects/Tests/Runtime/Connection/ConnectionApproval.cs
+++ b/com.unity.netcode.gameobjects/Tests/Runtime/Connection/ConnectionApproval.cs
@@ -40,6 +40,11 @@ public ConnectionApprovalTests(PlayerCreation playerCreation)
private string m_ValidationToken;
+ internal override bool ShouldCreatePlayerPrefab()
+ {
+ return m_PlayerCreation != PlayerCreation.NoPlayer && m_PlayerCreation != PlayerCreation.FailValidation;
+ }
+
protected override bool ShouldCheckForSpawnedPlayers()
{
return m_PlayerCreation != PlayerCreation.NoPlayer;
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/DistributedAuthority/DeferredDespawningTests.cs b/com.unity.netcode.gameobjects/Tests/Runtime/DistributedAuthority/DeferredDespawningTests.cs
index 1902539113..262d78dd0a 100644
--- a/com.unity.netcode.gameobjects/Tests/Runtime/DistributedAuthority/DeferredDespawningTests.cs
+++ b/com.unity.netcode.gameobjects/Tests/Runtime/DistributedAuthority/DeferredDespawningTests.cs
@@ -53,6 +53,9 @@ protected override void OnServerAndClientsCreated()
[UnityTest]
+#if ENABLE_CORECLR
+ [Explicit("NGO NetworkVariable serialization codegen not generated for some types on CoreCLR (falls back to FallbackSerializer), see https://jira.unity3d.com/browse/UUM-149592")]
+#endif
public IEnumerator DeferredDespawning()
{
// Setup for test
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/DistributedAuthority/DistributedAuthorityCodecTests.cs b/com.unity.netcode.gameobjects/Tests/Runtime/DistributedAuthority/DistributedAuthorityCodecTests.cs
index b6157324bc..fb88b9ada8 100644
--- a/com.unity.netcode.gameobjects/Tests/Runtime/DistributedAuthority/DistributedAuthorityCodecTests.cs
+++ b/com.unity.netcode.gameobjects/Tests/Runtime/DistributedAuthority/DistributedAuthorityCodecTests.cs
@@ -76,11 +76,6 @@ internal class TestNetworkComponent : NetworkBehaviour
{
public NetworkList MyNetworkList = new NetworkList(new List { 1, 2, 3 });
public NetworkVariable MyNetworkVar = new NetworkVariable(3);
-
- [Rpc(SendTo.Authority)]
- public void TestAuthorityRpc(byte[] _)
- {
- }
}
protected override void OnOneTimeSetup()
@@ -157,62 +152,6 @@ protected override IEnumerator OnStartedServerAndClients()
m_Client.MessageManager.Hook(m_ClientCodecHook);
}
- [UnityTest]
- public IEnumerator AuthorityRpc()
- {
- var player = m_Client.LocalClient.PlayerObject;
- player.OwnerClientId = m_Client.LocalClientId + 1;
-
- var networkComponent = player.GetComponent();
- networkComponent.UpdateNetworkProperties();
- networkComponent.TestAuthorityRpc(new byte[] { 1, 2, 3, 4 });
-
- // Universal Rpcs are sent as a ProxyMessage (which contains an RpcMessage)
- yield return m_ClientCodecHook.WaitForMessageReceived();
- }
-
- [UnityTest]
- public IEnumerator ChangeOwnership()
- {
- var message = new ChangeOwnershipMessage
- {
- DistributedAuthorityMode = true,
- NetworkObjectId = 100,
- OwnerClientId = 2,
- };
-
- yield return SendMessage(ref message);
- }
-
- [UnityTest]
- public IEnumerator ClientConnected()
- {
- var message = new ClientConnectedMessage()
- {
- ClientId = 2,
- };
-
- yield return SendMessage(ref message);
- }
-
- [UnityTest]
- public IEnumerator ClientDisconnected()
- {
- var message = new ClientDisconnectedMessage()
- {
- ClientId = 2,
- };
-
- yield return SendMessage(ref message);
- }
-
- [UnityTest]
- public IEnumerator CreateObject()
- {
- SpawnObject(m_SpawnObject, m_Client);
- yield return m_ClientCodecHook.WaitForMessageReceived();
- }
-
[UnityTest]
public IEnumerator DestroyObject()
{
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/DistributedAuthority/NetworkClientAndPlayerObjectTests.cs b/com.unity.netcode.gameobjects/Tests/Runtime/DistributedAuthority/NetworkClientAndPlayerObjectTests.cs
index 5697833bbc..fd0723e111 100644
--- a/com.unity.netcode.gameobjects/Tests/Runtime/DistributedAuthority/NetworkClientAndPlayerObjectTests.cs
+++ b/com.unity.netcode.gameobjects/Tests/Runtime/DistributedAuthority/NetworkClientAndPlayerObjectTests.cs
@@ -155,6 +155,9 @@ private bool AllNetworkClientsValidated()
/// Validates the same thing when a client late joins and when a client disconnects.
///
[UnityTest]
+#if ENABLE_CORECLR
+ [Explicit("ValidateNetworkClients throws duplicate-key ArgumentException on CoreCLR (DAHost), see https://jira.unity3d.com/browse/UUM-149595")]
+#endif
public IEnumerator ValidateNetworkClients()
{
// Validate the initial clients created
@@ -246,8 +249,7 @@ private bool ValidateAllPlayerObjects()
m_ErrorLogLevel1.AppendLine($"[Client-{client.LocalClientId}] Local {nameof(NetworkClient.PlayerObject)} is null!");
success = false;
}
- else
- if (!client.SpawnManager.PlayerObjects.Contains(client.LocalClient.PlayerObject))
+ else if (!client.SpawnManager.PlayerObjects.Contains(client.LocalClient.PlayerObject))
{
m_ErrorLogLevel1.AppendLine($"[Client-{client.LocalClientId}] Local {nameof(NetworkSpawnManager.PlayerObjects)} does not contain {client.LocalClient.PlayerObject.name}!");
success = false;
diff --git a/testproject/Assets/Tests/Runtime/Physics.meta b/com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples.meta
similarity index 77%
rename from testproject/Assets/Tests/Runtime/Physics.meta
rename to com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples.meta
index de0808f1a7..aea9d686c3 100644
--- a/testproject/Assets/Tests/Runtime/Physics.meta
+++ b/com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples.meta
@@ -1,5 +1,5 @@
fileFormatVersion: 2
-guid: efc90b4d4d76f7a48ad1cf726a3a193e
+guid: e017ce40eb7744e03bc0a83fa18ddcc3
folderAsset: yes
DefaultImporter:
externalObjects: {}
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples/Configuration.meta b/com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples/Configuration.meta
new file mode 100644
index 0000000000..baf6e6f199
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples/Configuration.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ac415df2337f69349996d9da97f07242
+folderAsset: yes
+DefaultImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples/Configuration/SinglePlayerSessions.cs b/com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples/Configuration/SinglePlayerSessions.cs
new file mode 100644
index 0000000000..7b46e03916
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples/Configuration/SinglePlayerSessions.cs
@@ -0,0 +1,223 @@
+using System.Collections;
+using System.Text;
+using NUnit.Framework;
+using Unity.Netcode;
+using Unity.Netcode.TestHelpers.Runtime;
+using Unity.Netcode.Transports.SinglePlayer;
+using Unity.Netcode.Transports.UTP;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace DocumentationCodeSamples
+{
+ #region SinglePlayerTransportExample
+ ///
+ /// Example of how to start a single player or multiplayer session.
+ /// Place this on your NetworkManager's GameObject.
+ ///
+ internal class SwitchingTransportTypesExample : MonoBehaviour
+ {
+ public enum StartType
+ {
+ SinglePlayer,
+ Client,
+ Host,
+ Server
+ }
+
+ private UnityTransport m_UnityTransport;
+ private SinglePlayerTransport m_SinglePlayerTransport;
+ private NetworkManager m_NetworkManager;
+
+ private void Awake()
+ {
+ m_UnityTransport = GetComponent();
+ m_SinglePlayerTransport = GetComponent();
+ m_NetworkManager = GetComponent();
+ }
+
+ public bool StartSession(StartType startType)
+ {
+ var startStatus = false;
+ // Set the transport to use before starting
+ m_NetworkManager.NetworkConfig.NetworkTransport = startType == StartType.SinglePlayer ? m_SinglePlayerTransport : m_UnityTransport;
+ switch (startType)
+ {
+ case StartType.Host:
+ case StartType.SinglePlayer:
+ {
+ // Starting a host or single player is the same
+ startStatus = m_NetworkManager.StartHost();
+ break;
+ }
+ case StartType.Server:
+ {
+ startStatus = m_NetworkManager.StartServer();
+ break;
+ }
+ case StartType.Client:
+ {
+ startStatus = m_NetworkManager.StartClient();
+ break;
+ }
+ }
+ return startStatus;
+ }
+ }
+ #endregion
+
+ internal class VerifyNetcodeSessionActive : NetworkBehaviour
+ {
+ public bool RpcReceived { get; private set; }
+
+ public bool TestNetworkVariableEvent { get; private set; }
+ public NetworkVariable TestNetworkVariable = new NetworkVariable(false, NetworkVariableReadPermission.Everyone, NetworkVariableWritePermission.Owner);
+
+ [Rpc(SendTo.Everyone, InvokePermission = RpcInvokePermission.Owner)]
+ private void VerifyRpc(RpcParams rpcParams = default)
+ {
+ RpcReceived = true;
+ }
+
+ public void TestConnectivity()
+ {
+ if (IsOwner)
+ {
+ VerifyRpc();
+ TestNetworkVariable.Value = true;
+ }
+ }
+
+ protected override void OnNetworkPostSpawn()
+ {
+ TestNetworkVariable.OnValueChanged += TestNetworkVariableChanged;
+ base.OnNetworkPostSpawn();
+ }
+
+ private void TestNetworkVariableChanged(bool previous, bool current)
+ {
+ TestNetworkVariableEvent = true;
+ }
+ }
+
+ [TestFixture(SessionType.SinglePlayer)]
+ [TestFixture(SessionType.MultiPlayer)]
+ internal class SwitchingTransportTypesTests : NetcodeIntegrationTest
+ {
+ public enum SessionType
+ {
+ SinglePlayer,
+ MultiPlayer
+ }
+
+ protected override int NumberOfClients => 0;
+
+ // We do not need to test this against CMB.
+ protected override bool UseCMBService()
+ {
+ return false;
+ }
+
+ private SessionType m_SessionType;
+ public SwitchingTransportTypesTests(SessionType sessionType)
+ {
+ m_SessionType = sessionType;
+ }
+
+ protected override IEnumerator OnSetup()
+ {
+ m_CanStart = false;
+ return base.OnSetup();
+ }
+
+ protected override void OnCreatePlayerPrefab()
+ {
+ m_PlayerPrefab.AddComponent();
+ base.OnCreatePlayerPrefab();
+ }
+
+ private bool m_CanStart = false;
+ protected override bool CanStartServerAndClients()
+ {
+ return m_CanStart;
+ }
+
+ private NetworkManager m_Client;
+ protected override void OnNewClientCreated(NetworkManager networkManager)
+ {
+ m_Client = networkManager;
+ networkManager.NetworkConfig.EnableSceneManagement = false;
+ base.OnNewClientCreated(networkManager);
+ }
+
+ [UnityTest]
+#if ENABLE_CORECLR
+ [Explicit("NGO NetworkVariable serialization codegen not generated for some types on CoreCLR (falls back to FallbackSerializer), see https://jira.unity3d.com/browse/UUM-149592")]
+#endif
+ public IEnumerator SwitchTransportTest()
+ {
+ var authority = GetAuthorityNetworkManager();
+ authority.NetworkConfig.EnableSceneManagement = false;
+ var startType = SwitchingTransportTypesExample.StartType.Host;
+ if (m_SessionType == SessionType.SinglePlayer)
+ {
+ startType = SwitchingTransportTypesExample.StartType.SinglePlayer;
+ authority.gameObject.AddComponent();
+ }
+ m_CanStart = true;
+ var example = authority.gameObject.AddComponent();
+ Assert.IsTrue(example.StartSession(startType), "Failed to start single player session!");
+
+ if (m_SessionType != SessionType.SinglePlayer)
+ {
+ yield return CreateAndStartNewClient();
+ AssertOnTimeout("Timed out waiting for client to start and connect!");
+ }
+
+ var verifyNetcode = authority.LocalClient.PlayerObject.GetComponent();
+ verifyNetcode.TestConnectivity();
+ if (m_SessionType != SessionType.SinglePlayer)
+ {
+ m_Client.LocalClient.PlayerObject.GetComponent().TestConnectivity();
+ }
+
+ yield return WaitForConditionOrTimeOut(VerifyNetcodeSession);
+ AssertOnTimeout($"Single player session had netcode related errors:");
+ }
+
+ ///
+ /// Verifies that all spawned players received the RPC and NetworkVariable
+ /// changed event.
+ ///
+ private bool VerifyNetcodeSession(StringBuilder errorLog)
+ {
+ foreach (var networkManager in m_NetworkManagers)
+ {
+ foreach (var networkObject in networkManager.SpawnManager.SpawnedObjectsList)
+ {
+ if (!networkObject.IsPlayerObject)
+ {
+ continue;
+ }
+ var verify = networkObject.gameObject.GetComponent();
+
+ if (!verify.RpcReceived)
+ {
+ errorLog.AppendLine($"[Client-{networkManager.LocalClientId}][{verify.name}] Rpc was not recieved!");
+ }
+
+ if (!verify.TestNetworkVariableEvent)
+ {
+ errorLog.AppendLine($"[Client-{networkManager.LocalClientId}][{verify.name}] NetworkVariable.OnValueChanged did not get invoked!");
+ }
+
+ if (!verify.TestNetworkVariable.Value)
+ {
+ errorLog.AppendLine($"[Client-{networkManager.LocalClientId}][{verify.name}] {nameof(VerifyNetcodeSessionActive.TestNetworkVariable)} did not get set!");
+ }
+ }
+ }
+ return errorLog.Length == 0;
+ }
+ }
+}
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples/Configuration/SinglePlayerSessions.cs.meta b/com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples/Configuration/SinglePlayerSessions.cs.meta
new file mode 100644
index 0000000000..bd9ea061b2
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples/Configuration/SinglePlayerSessions.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: cd8ec5118fc47e449ae915c51a3806b4
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples/NetworkVariable.meta b/com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples/NetworkVariable.meta
new file mode 100644
index 0000000000..6fc7d1074d
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples/NetworkVariable.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 446ef307887e3446f896c899f43af442
+folderAsset: yes
+DefaultImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples/NetworkVariable/CustomNetworkVariable.cs b/com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples/NetworkVariable/CustomNetworkVariable.cs
new file mode 100644
index 0000000000..74fb7fe157
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples/NetworkVariable/CustomNetworkVariable.cs
@@ -0,0 +1,239 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using NUnit.Framework;
+using Unity.Netcode;
+using Unity.Netcode.TestHelpers.Runtime;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace DocumentationCodeSamples
+{
+ #region TestMyCustomNetworkVariable
+ // Using MyCustomNetworkVariable within a NetworkBehaviour
+ internal class TestMyCustomNetworkVariable : NetworkBehaviour
+ {
+ public MyCustomNetworkVariable CustomNetworkVariable = new MyCustomNetworkVariable();
+ public MyCustomGenericNetworkVariable CustomGenericNetworkVariable = new MyCustomGenericNetworkVariable();
+
+ public override void OnNetworkSpawn()
+ {
+ if (IsServer)
+ {
+ for (int i = 0; i < 4; i++)
+ {
+ var someData = new SomeData
+ {
+ SomeFloatData = i,
+ SomeIntData = i
+ };
+ someData.SomeListOfValues.Add((ulong)i + 1000000);
+ someData.SomeListOfValues.Add((ulong)i + 2000000);
+ someData.SomeListOfValues.Add((ulong)i + 3000000);
+ CustomNetworkVariable.SomeDataToSynchronize.Add(someData);
+ CustomNetworkVariable.SetDirty(true);
+
+ CustomGenericNetworkVariable.SomeDataToSynchronize.Add(i);
+ CustomGenericNetworkVariable.SetDirty(true);
+ }
+ }
+ }
+ }
+
+ ///
+ /// Bare minimum example of NetworkVariableBase derived class
+ ///
+ [Serializable]
+ public class MyCustomNetworkVariable : NetworkVariableBase
+ {
+ ///
+ /// Managed list of class instances
+ ///
+ internal List SomeDataToSynchronize = new List();
+
+ ///
+ /// Writes the complete state of the variable to the writer
+ ///
+ /// The stream to write the state to
+ public override void WriteField(FastBufferWriter writer)
+ {
+ // Serialize the data we need to synchronize
+ writer.WriteValueSafe(SomeDataToSynchronize.Count);
+ foreach (var dataEntry in SomeDataToSynchronize)
+ {
+ writer.WriteValueSafe(dataEntry.SomeIntData);
+ writer.WriteValueSafe(dataEntry.SomeFloatData);
+ writer.WriteValueSafe(dataEntry.SomeListOfValues.Count);
+ foreach (var valueItem in dataEntry.SomeListOfValues)
+ {
+ writer.WriteValueSafe(valueItem);
+ }
+ }
+ }
+
+ ///
+ /// Reads the complete state from the reader and applies it
+ ///
+ /// The stream to read the state from
+ public override void ReadField(FastBufferReader reader)
+ {
+ // De-Serialize the data being synchronized
+ var itemsToUpdate = 0;
+ reader.ReadValueSafe(out itemsToUpdate);
+ SomeDataToSynchronize.Clear();
+ for (int i = 0; i < itemsToUpdate; i++)
+ {
+ var newEntry = new SomeData();
+ reader.ReadValueSafe(out newEntry.SomeIntData);
+ reader.ReadValueSafe(out newEntry.SomeFloatData);
+ var itemsCount = 0;
+ var tempValue = (ulong)0;
+ reader.ReadValueSafe(out itemsCount);
+ newEntry.SomeListOfValues.Clear();
+ for (int j = 0; j < itemsCount; j++)
+ {
+ reader.ReadValueSafe(out tempValue);
+ newEntry.SomeListOfValues.Add(tempValue);
+ }
+
+ SomeDataToSynchronize.Add(newEntry);
+ }
+ }
+
+ ///
+ /// Used to write partial updates rather than synchronizing the full state on every change.
+ ///
+ /// The stream to write the state to
+ public override void WriteDelta(FastBufferWriter writer)
+ {
+ // Not implemented for this example, instead we can write the field
+ WriteField(writer);
+ }
+
+ ///
+ /// Used to read partial updates rather than synchronizing the full state on every change.
+ ///
+ ///
+ public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
+ {
+ // Not implemented for this example, instead we can read the field
+ ReadField(reader);
+ }
+
+ }
+
+ ///
+ /// Bare minimum example of generic NetworkVariableBase derived class
+ ///
+ /// Generic type marker
+ [Serializable]
+ [GenerateSerializationForGenericParameter(0)]
+ public class MyCustomGenericNetworkVariable : NetworkVariableBase
+ {
+ /// Managed list of class instances
+ public List SomeDataToSynchronize = new List();
+
+ ///
+ /// Writes the complete state of the variable to the writer
+ ///
+ /// The stream to write the state to
+ public override void WriteField(FastBufferWriter writer)
+ {
+ // Serialize the data we need to synchronize
+ writer.WriteValueSafe(SomeDataToSynchronize.Count);
+ for (var i = 0; i < SomeDataToSynchronize.Count; ++i)
+ {
+ var dataEntry = SomeDataToSynchronize[i];
+ // NetworkVariableSerialization is used for serializing generic types
+ NetworkVariableSerialization.Write(writer, ref dataEntry);
+ }
+ }
+
+ ///