com.unity.netcode@0.2.0-preview.5

## [0.2.0-preview.5] - 2020-06-05
### New features
* Support for pre-spawned ghosts. When prefab ghost instances are placed into subscenes they will be present on server and clients when they load the scene. They are then automatically connected together and will work just like normally spawned ghosts after that.

### Changes
* Changed how snapshot size is limited to make it more robust and give more clear errors.
* Added `Name` field to the `GhostAuthoringComponent`  which is used during code generation to identify the ghost prefab. By default this is the prefab name but can be changed.
* `ClientServerBoostrap` now correctly use two-phase initialization to initialise all the systems
* Changed `PhysicsWorldHistory.CollisionHistoryBuffer` to return a safe memory reference to the `CollisionHistoryBuffer` instead of copy a large amount of data on the stack.
* Upgrade to Entities 0.11

### Fixes
* Fixed issue with ghost prefabs when they were Variant or Model Prefabs.
* Fixed issue with datastream going out of sync when snapshot desync was detected
* Fixed an issue with `RegisterRPC` in case you try to register a malformed RPC with an invalid pointer
* Fixed an issue with `ServerTick` that does not monotonically increase in presence of high ping
* Fixed an issue with `ClientServerTickRate` being created multiple times if the client connect and disconnect from the server
* Fixed an issue with `ClientServerTickRate` not reused by the client if it was already present in the world
* Fixed an issue with `ClientServerBootstrap` and the fact `TypeManager` was not initialised when we generate client/server world's the system lists

### Upgrade guide

* A `Name` field was added to the `GhostAuthoringComponent` and as a result all prefabs with this component need to be opened and close to serialize the field. It's used as a prefix name during code generation so it might also be neccessary to press the _Generate Code_ button again

Author: Unity Technologies

CHANGELOG.md

@@ -1,5 +1,29 @@
 # Change log
 
+## [0.2.0-preview.5] - 2020-06-05
+### New features
+* Support for pre-spawned ghosts. When prefab ghost instances are placed into subscenes they will be present on server and clients when they load the scene. They are then automatically connected together and will work just like normally spawned ghosts after that.
+
+### Changes
+* Changed how snapshot size is limited to make it more robust and give more clear errors.
+* Added `Name` field to the `GhostAuthoringComponent`  which is used during code generation to identify the ghost prefab. By default this is the prefab name but can be changed.
+* `ClientServerBoostrap` now correctly use two-phase initialization to initialise all the systems
+* Changed `PhysicsWorldHistory.CollisionHistoryBuffer` to return a safe memory reference to the `CollisionHistoryBuffer` instead of copy a large amount of data on the stack.
+* Upgrade to Entities 0.11
+
+### Fixes
+* Fixed issue with ghost prefabs when they were Variant or Model Prefabs.
+* Fixed issue with datastream going out of sync when snapshot desync was detected
+* Fixed an issue with `RegisterRPC` in case you try to register a malformed RPC with an invalid pointer
+* Fixed an issue with `ServerTick` that does not monotonically increase in presence of high ping
+* Fixed an issue with `ClientServerTickRate` being created multiple times if the client connect and disconnect from the server
+* Fixed an issue with `ClientServerTickRate` not reused by the client if it was already present in the world
+* Fixed an issue with `ClientServerBootstrap` and the fact `TypeManager` was not initialised when we generate client/server world's the system lists
+
+### Upgrade guide
+
+* A `Name` field was added to the `GhostAuthoringComponent` and as a result all prefabs with this component need to be opened and close to serialize the field. It's used as a prefix name during code generation so it might also be neccessary to press the _Generate Code_ button again
+
 ## [0.1.0-preview.6] - 2020-02-24
 ### New features
 * Added integration with UnityPhysics, including the lag compensation from DotsSample. To use it you must have the UnityPhysics added to your project.

Documentation~/getting-started.md

@@ -42,11 +42,16 @@ public struct MovableCubeComponent : IComponentData
 
 Once you create this component, add it to the Cube Prefab. Then, in the Inspector, add the __Ghost Authoring Component__ to the Prefab. In this component, select __Update Component List__ to update the list of components.
 
-When you do this, Unity automatically adds default values to the Translation and Rotation components. Expand the components in the list to select where they should be present. In this example, disable `PerInstanceCullingTag` and `RenderMesh` on the server. This is because the server does not render anything, and interpolated objects on the client don’t simulate anything.
 
-![The Ghost Authoring component](images/ghost-config.png)<br/>_The Ghost Authoring component_
 
-**Note:** Change the __Default Client Instantiation__ to __Owner Predicted__. This makes sure that you predict your own movement.
+When you do this, Unity automatically adds default values to the Translation and Rotation components. 
+
+Start by changing the __Default Client Instantiation__ to __Owner Predicted__. This makes sure that you predict your own movement. Then, add the `MovableCubeComponent.PlayerId` to the
+__Predicting player network id__ field. 
+
+Now, expand the components in the list to select where they should be present. In this example, disable `PerInstanceCullingTag`, `RenderBounds` and `RenderMesh` on the server. The server doesn't render anything and interpolated objects on the client don't simulate anything, so these settings aren't required.
+
+![The Ghost Authoring component](images/ghost-config.png)<br/>_The Ghost Authoring component_
 
 After you set up the component, select the __Generate Code__ button.
 
@@ -118,11 +123,11 @@ In *Game.cs*, create the following [RpcCommand](https://docs.unity3d.com/Package
 [BurstCompile]
 public struct GoInGameRequest : IRpcCommand
 {
-    public void Deserialize(DataStreamReader reader, ref DataStreamReader.Context ctx)
+    public void Deserialize(ref DataStreamReader reader)
     {
     }
 
-    public void Serialize(DataStreamWriter writer)
+    public void Serialize(ref DataStreamWriter writer)
     {
     }
     [BurstCompile]
@@ -161,28 +166,28 @@ public struct CubeInput : ICommandData<CubeInput>
     public int horizontal;
     public int vertical;
 
-    public void Deserialize(uint tick, DataStreamReader reader, ref DataStreamReader.Context ctx)
+    public void Deserialize(uint tick, ref DataStreamReader reader)
     {
         this.tick = tick;
-        horizontal = reader.ReadInt(ref ctx);
-        vertical = reader.ReadInt(ref ctx);
+        horizontal = reader.ReadInt();
+        vertical = reader.ReadInt();
     }
 
-    public void Serialize(DataStreamWriter writer)
+    public void Serialize(ref DataStreamWriter writer)
     {
-        writer.Write(horizontal);
-        writer.Write(vertical);
+        writer.WriteInt(horizontal);
+        writer.WriteInt(vertical);
     }
 
-    public void Deserialize(uint tick, DataStreamReader reader, ref DataStreamReader.Context ctx, CubeInput baseline,
+    public void Deserialize(uint tick, ref DataStreamReader reader, CubeInput baseline,
         NetworkCompressionModel compressionModel)
     {
-        Deserialize(tick, reader, ref ctx);
+        Deserialize(tick, ref reader);
     }
 
-    public void Serialize(DataStreamWriter writer, CubeInput baseline, NetworkCompressionModel compressionModel)
+    public void Serialize(ref DataStreamWriter writer, CubeInput baseline, NetworkCompressionModel compressionModel)
     {
-        Serialize(writer);
+        Serialize(ref writer);
     }
 }
 ```

Documentation~/ghost-snapshots.md

@@ -74,6 +74,46 @@ You need to implement some specific code to handle the predicted spawning for pl
 
 NetCode spawns entities on the client with a Prefab stored in the `GhostPrefabCollectionComponent` singleton. A `GhostCollectionAuthoringComponent` and a `ConvertToClientServerEntity` component that uses Client as the conversion target creates the Prefab.
 
+## Prespawned ghosts
+
+A ghost instance (an instance of a ghost prefab) can be placed in a subscene in the Unity editor so that it will be treated just like a normal spawned ghost when the player has loaded the data. There are two restrictions for prespwaned ghosts. Firstly, it must be an instance of a ghost prefab which has been registered in the ghost collection. Secondly, it must be place in a subscene.
+
+The ghost authoring component on the prespawned ghost cannot be configured differently than the ghost prefab source, since that data is handled on a ghost type basis.
+
+Each subscene applies prespawn IDs to the ghosts it contains in a deterministic manner. The subscene hashes the component data on the ghosts, which currently is only the `Rotation` and `Translation` components. It also keeps a single hash composed of all the ghost data for the subscene itself. 
+
+At runtime, when all subscenes have been loaded, there is a process which applies the prespawn ghost IDs to the ghosts as normal runtime ghost IDs. This has to be done after all subscenes have finished loading and the game is ready to start. It is also done deterministically, so that for each player (server or client), the ghost IDs are applied in exactly the same way. This happens when the `NetworkStreamInGame` component has been added to the network connection. Currently, there is no reliable builtin way to detect when subscenes have been loaded. However, it's possible to do so manually. To do this, add a custom tag to every subscene, then count the number of tags to detect when all subscenes are ready.
+
+An alternative way to detect whether subscenes have finished loading without using tags is to check if the prespawn ghost count is correct. The following example shows one possible solution for checking this number, in this case testing for 7 ghosts across all loaded subscenes:
+
+```c#
+[UpdateInGroup(typeof(ClientSimulationSystemGroup))]
+public class GoInGameClientSystem : ComponentSystem
+{
+    public int ExpectedGhostCount = 7;
+    protected override void OnUpdate()
+    {
+        var prespawnCount = EntityManager.CreateEntityQuery(ComponentType.ReadOnly<PreSpawnedGhostId>()).CalculateEntityCount();
+        Entities.WithNone<NetworkStreamInGame>().ForEach((Entity ent, ref NetworkIdComponent id) =>
+        {
+            if (ExpectedGhostCount == prespawnCount)
+                PostUpdateCommands.AddComponent<NetworkStreamInGame>(ent);
+        });
+    }
+}
+```
+
+To create a prespawned ghost from a normal scene you can do the following:
+* Right click on the *Hierarchy* in the inspector and click *New Sub Scene*.
+* Drag an instance of a ghost prefab into the newly created subscene.
+
+This feature is new and is liable to change in the future. The current implementation has some limitations which are listed below:
+* With regard to using subscenes, when placing an object in a subscene, you no longer place the `ConvertToClientServerEntity` component on it as being in a subscene implies conversion to an Entity. Also, it means the option of making an entity only appear on the client or server is now missing. Prespawned ghosts always appear on both client and server as they are just like a normal spawned ghost, and will always be synchronized (as configured) after the game starts.
+* Loading a new subscene with prespawned ghosts after starting (entering the game) is currently not supported.
+* Only the `Translation` and `Rotation` `IComponentData` components, converted from the `Transform` component, are currently used to generate the prespawn IDs. This means that the prespawn ghosts cannot be placed in the same location and these components are required to use prespawn ghosts.
+
+To look at an example of a scene using prespawn ghosts, see the test in *Assets/Tests/PrespawnTests*. This is used in some of the tests inside the sample project.
+
 ## Snapshot visualization tool
 
-To understand what is being put on the wire in the netcode, you can use the prototype snapshot visualization tool, __NetDbg__ in the Stats folder. To open the tool, go to menu: __Multiplayer &gt; Open NetDbg__, and the tool opens in a browser window. It displays a vertical bar for each snapshot Unity receives, with a breakdown of the snapshot’s ghost types. To see more detailed information about the snapshot, click on one of the bars. __Note:__ This tool is a prototype. In future versions of the package it will integrate with the Unity Profiler so you can easily correlate network traffic with memory usage and CPU performance.
+To understand what is being put on the wire in the netcode, you can use the prototype snapshot visualization tool, __NetDbg__ in the Stats folder. To open the tool, go to menu: __Multiplayer &gt; Open NetDbg__, and the tool opens in a browser window. It displays a vertical bar for each snapshot Unity receives, with a breakdown of the snapshot’s ghost types. To see more detailed information about the snapshot, click on one of the bars. __Note:__ This tool is a prototype. In future versions of the package it will integrate with the Unity Profiler so you can easily correlate network traffic with memory usage and CPU performance.