DOTS Multiplayer discussion

My question now in public Issue Tracker, please give vote
https://issuetracker.unity3d.com/product/unity/issues/guid/1265171

 

With 0.3.0 being released are you all at any point going to update or consolidate the many samples that are out there?

This is one I have learned from in the past https://github.com/Unity-Technologies/DOTSSample, but there are a lot of changes in the animation package (0.6.0) and after messing with it for about 2 hours today I have decided it isnt worth it. Updating the netcode wasn't horrible, but the animation stuff is just broken.

I know stuff is still in preview, but the samples are worth while to the community. The Unity Sample Core stuff are good simple samples, but need a bit more meat.

Thanks!

 

The multiplayer sample here https://github.com/Unity-Technologies/multiplayer are always updated to the latest release.

The DOTS sample project is used by unity internally to validate and test their new versions and they mentioned they often use unity engine versions that are ahead of the public versions and thats why they cant update it often, that said unity said they would update it last month, but didn't do it, maybe if you are lucky it will receive an update soon.

 

How do handle GhostSnapshotValue with Netcode 0.3? It seems all remnants of GhostSnapshotValue have been removed, but there is nothing in the changelog about what to use now or how this is handled.

Also the links in this post are not available for me. Perhaps I need to be included in some sort of organization to see them?

 

in netcode3 there is a bug where if irpcommand struct is either set to internal or private, project becomes stuck in an endless code generation loop and crashes after a bit of time.

 

@timjohansson huge fan of the updates in netcode 0.4 thank you

Big fan of simplifying how to define command data!!! https://github.com/Unity-Technologi...267da9e#diff-74e27b9d17e18a1292a3fee7ce7bbc9d

Questions:

1. Is there a timeline on updated docs for 0.4?
2. "Upgraded all NetCode samples to use subscenes instead of ConvertToEntity. This means you now have to use the files in BuildSettings to make a standalone build." Curious why you made this call?

 

@timjohansson probably not the best place to ask but... where is the right place to look on documentation on how to handle the subscene workflow?

I checked out the ECS/Netcode/Transport documentation and the Unite videos and haven't found a good "what and why" for the best way to structure a project with scenes/subscenes for ECS.

 

Just wanted to add to this the fact that for priorities, we need to be able to set an entity's chunk based on something other than distance and somehow use a per chunk component to say how that chunk's priority changes.

In a game similar to say Halo with lots of objects and based on object importance, some very close object, a grenade on ground with a good distance, is not as important as the rocket coming toward you from far away.

 

@timjohansson I wanted to double check that the docs in "Getting Started" is out of date and we shouldn't use ConvertToClientServerEntity component.



It seems like the docs further down in "Getting Started" are updated with the new patterns so I wanted to make sure I didn't misunderstand something.

 

Help me please, how to change PrefabType at GhostComponent generated by unity? At my own components i can add [GhostComponent(PrefabType=...)] attribute, but how do this at other components ? For example - PhysicsCollider, PhysicsMass etc

 

@timjohansson I was wondering about the BuildSettings folder in the multiplayer example...

1. Is there a place I should look to understand what are good approaches to "BuildSettings" for networked projects? (I am pretty sure my next questions are rudimentary...)

2. Why does OSX have 3 different BuildSettings files, while Linux and Win have 2.


3. What is up with "Base, Client, Server" and how does that relate to the platform specific files?
4. If I wanted to deploy to WebGL would I have to make a WebGL - Client BuildSettings file?

 

@timjohansson

Another addition I noticed with the github multiplayer update is:

- ConfigureEditorSystem.cs
- ConfigureSystems.cs



1. Is there any where I can go that explains these systems?
I checked out the ECS documentation and wasn't able to find any information about the addition of these systems.

2. Are these systems now required for netcode, what do they do?
(I see what the system does but why is it now needed in netcode 0.4)

3. What is up with the the hash?


Thank you!

 

@timjohansson

Hoping to understand if I am understanding the multiplayer Asteroids example correctly for the server loading a level to a client.

From LoadLevelSystem.cs (server folder)

Code (CSharp):

1. protected override void OnUpdate()
2.         {
3.             ...
4.             JobHandle levelDep;
5.             var commandBuffer = m_Barrier.CreateCommandBuffer();
6.             var level = m_LevelGroup.ToComponentDataArrayAsync<LevelComponent>(Allocator.TempJob, out levelDep);
7.  
8.             var requestLoadJob = Entities.WithNone<LevelRequestedTag>().WithReadOnly(level).WithDisposeOnCompletion(level).
9.                 ForEach((Entity entity, in NetworkIdComponent netId) =>
10.             {
11.                 commandBuffer.AddComponent(entity, new LevelRequestedTag());
12.                 var req = commandBuffer.CreateEntity();
13.                 commandBuffer.AddComponent(req, new LevelLoadRequest
14.                 {
15.                     width = level[0].width,
16.                     height = level[0].height,
17.                     playerForce = level[0].playerForce,
18.                     bulletVelocity = level[0].bulletVelocity
19.                 });
20.                 commandBuffer.AddComponent(req, new SendRpcCommandRequestComponent {TargetConnection = entity});
21.             }).Schedule(JobHandle.CombineDependencies(Dependency, levelDep));
22.             Dependency = requestLoadJob;
23.             m_Barrier.AddJobHandleForProducer(Dependency);
24.         }

- Because we want to pass through LevelComponent data to a job (the job will be sending an RPC to the client) we need to get the data in a NativeArray
- We use `ToComponentDataArrayAsync` to put the component data in a NativeArray and because this is Async we also save the dependencies of this work to `levelDep`
- We are able to pass through the NativeArray data to the job through the `.WithReadOnly` method and are able to ensure we clean up our memory using the `.WithDisposeOnCompletion` method
- We are able to query to the Network Connection Entities by querying for entities with a NetworkIdComponent
- We know which Network Connection Entity (NCE) to send RPCs through based on the NCE not having a LevelRequestedTag

Here is where I am hoping you could clarify...

1. I am having a tough time wrapping my head around this line here:

`.Schedule(JobHandle.CombineDependencies(Dependency, levelDep))`

From the documentation on the Dependency property:

By default, a system manages its ECS-related dependencies using its Dependency property. By default, the system adds each job created with Entities.ForEach and [Job.WithCode] to the Dependency job handle in the order that they appear in the OnUpdate() function. You can also manage job dependencies manually by passing a [JobHandle] to your Schedule functions, which then return the resulting dependency. See Dependency for more information.

Before OnUpdate(), the Dependency property represents the combined job handles of any job that writes to the same components that the current system reads -- or reads the same components that the current system writes to. When you use Entities.ForEach or Job.WithCode, the system uses the Dependency property to specify a job’s dependencies when scheduling it. The system also combines the new job's JobHandle with Dependency so that any subsequent job scheduled in the system depends on the earlier jobs (in sequence).​

We are able to combine both the dependencies of the job and the memory allocation job with .CombineDependencies(Dependency, levelDep)

Does this mean that Unity has already added the requestLoadJob's dependencies to Dependency before `.CombineDependencies` has been called? OR, is Unity combining the dependencies of before the OnUpdate loop with the dependencies of levelDep, and then requestLoadJob's dependencies are added automatically and not explicitly.

2. I have updated the code to remove returning a JobHandle

Code (CSharp):

1. protected override void OnUpdate()
2.         {
3.             ...
4.             JobHandle levelDep;
5.             var commandBuffer = m_Barrier.CreateCommandBuffer();
6.             var level = m_LevelGroup.ToComponentDataArrayAsync<LevelComponent>(Allocator.TempJob, out levelDep);
7.  
8.             Entities.WithNone<LevelRequestedTag>().WithReadOnly(level).WithDisposeOnCompletion(level).
9.                 ForEach((Entity entity, in NetworkIdComponent netId) =>
10.             {
11.                 commandBuffer.AddComponent(entity, new LevelRequestedTag());
12.                 var req = commandBuffer.CreateEntity();
13.                 commandBuffer.AddComponent(req, new LevelLoadRequest
14.                 {
15.                     width = level[0].width,
16.                     height = level[0].height,
17.                     playerForce = level[0].playerForce,
18.                     bulletVelocity = level[0].bulletVelocity
19.                 });
20.                 commandBuffer.AddComponent(req, new SendRpcCommandRequestComponent {TargetConnection = entity});
21.             }).Schedule(JobHandle.CombineDependencies(Dependency, levelDep));
22.             m_Barrier.AddJobHandleForProducer(Dependency);
23.         }

The code runs, is this "lucky" or expected behavior?

3. If this was a game where 2,000 clients could connect and play simultaneously, would there be anything from preventing the requestLoadJob to use ScheduleParallel() (to speed up sending out RPCs to clients)?

4. Finally, I was wondering if there is documentation on all the components that a Network Connection Entity comes with, or needs at some point?

For some reason I cannot find in the manual or the API documentation what components "come with" a NCE (like NetworkIdComponent). You can find things like NetworkIdComponent in the documentation, but not that its parent is NCE, or that it "comes with" an NCE.

NCE
- CommandTargetComponent
- NetworkIdComponent
- NetworkStreamInGame
- GhostConnectionPosition
- NetworkStreamDisconnected
- OutgoingRpcDataStreamBufferComponent

Also in the Asteroids sample there are different ways of getting to the NCE using a .ForEach. LoadLevelSystem on server uses "NetworkIdComponent", InputSystem on the client uses "OutgoingRpcDataStreamBufferComponent". What is a good approach and when?

Knowledge of how to interface with the NCE seems to be key to netcode, would be great if there was something to explain how NCE's are made (I know its from a socket connection, but needed to be inferred) and what they come with.

 

@timjohansson

A few questions on LoadLevelSystem on the client/server, trying to understand how RPC's are being handled by netcode.

My understanding:

From Network connection documentation:

- So the Network Connection Entity (NCE) has 2 buffers for RPCs, 1 for incoming RPCs and 1 for outgoing RPCs

From the RPC documentation:


From the Asteroids sample (in LoadLevelSystem.cs in server):

Code (CSharp):

1. var req = commandBuffer.CreateEntity();
2.                 commandBuffer.AddComponent(req, new LevelLoadRequest
3.                 {
4.                     width = level[0].width,
5.                     height = level[0].height,
6.                     playerForce = level[0].playerForce,
7.                     bulletVelocity = level[0].bulletVelocity
8.                 });
9.                 commandBuffer.AddComponent(req, new SendRpcCommandRequestComponent {TargetConnection = entity});

- So we create an entity (req) and add the RPC component and the SendRpcCommandRequestComponent, great

From RPCs documentation:

In the previous example, the RpcExecutor.ExecuteCreateRequestComponent<OurRpcCommand>(ref parameters); function call to the IRpCommand creates an entity that you can filter on. To test if this works, the following example creates a system that receives the OurRpcCommand:
...
The RpcSystem automatically finds all of the requests, sends them, and then deletes the send request. On the remote side they show up as entities with the same IRpcCommand and a ReceiveRpcCommandRequestComponent which you can use to identify which connection the request was received from.
...
​

1. When is RpcExecutor.ExecuteCreateRequestComponent<LevelLoadRequest>(ref parameters) called? Who calls it? When is this triggered, and what triggers it?
I have read and re-read the netcode documentation on RPCs and the scripting documentation and can't make sense of the sentence "the RpcExecutor.ExecuteCreateRequestComponent<OurRpcCommand>(ref parameters); function call to the IRpCommand creates an entity that you can filter on".

2. What is up with TActionSerializer, TActionRequest?
From documentation:

I get from the Asteroids sample that in order to use GetRpcQueue you need to enumerate the RPC twice (.GetRpcQueue<RpcLevelLoaded, RpcLevelLoaded>()) but I don't understand why it needs to be enumerated twice. Why are we calling the Rpc TActionSerializer and TActionRequest?


From the LoadLevelSystem on the client:

Code (CSharp):

1. var commandBuffer = m_Barrier.CreateCommandBuffer().AsParallelWriter();
2.             var rpcFromEntity = GetBufferFromEntity<OutgoingRpcDataStreamBufferComponent>();
3.             var levelFromEntity = GetComponentDataFromEntity<LevelComponent>();
4.             var levelSingleton = m_LevelSingleton;
5.             var rpcQueue = m_RpcQueue;
6.             Entities.ForEach((Entity entity, int nativeThreadIndex, in LevelLoadRequest request, in ReceiveRpcCommandRequestComponent requestSource) =>
7.             {
8.                 commandBuffer.DestroyEntity(nativeThreadIndex, entity);
9.                 // Check for disconnects
10.                 if (!rpcFromEntity.HasComponent(requestSource.SourceConnection))
11.                     return;
12.                 // set the level size - fake loading of level
13.                 levelFromEntity[levelSingleton] = new LevelComponent
14.                 {
15.                     width = request.width,
16.                     height = request.height,
17.                     playerForce = request.playerForce,
18.                     bulletVelocity = request.bulletVelocity
19.                 };
20.                 commandBuffer.AddComponent(nativeThreadIndex, requestSource.SourceConnection, new PlayerStateComponentData());
21.                 commandBuffer.AddComponent(nativeThreadIndex, requestSource.SourceConnection, default(NetworkStreamInGame));
22.                 rpcQueue.Schedule(rpcFromEntity[requestSource.SourceConnection], new RpcLevelLoaded());
23.             }).Schedule();
24.             m_Barrier.AddJobHandleForProducer(Dependency);

3. Any specific reason we are destroying the entity using DestroyEntity(nativeThreadIndex, entity) instead of DestroyEntity(entity)?
Wasn't sure if there was a reason or it was arbitrary. Why we going the ThreadIndex route?

4. Any specific reason we are adding a component using AddComponent(nativeThreadIndex, requestSource.SourceConnection, new PlayerStateComponentData()) instead of AddComponent(requestSource.SourceConnection, new PlayerStateComponentData())?
Why are we using threadIndex's here?

5. Why are we sending an rpc with rpcQueue.Schedule(rpcFromEntity[requestSource.SourceConnection], new RpcLevelLoaded()) instead of sending it how the server did, with a SendRpcCommandRequestComponent? Is there any situations/benefits for using the OutgoingRpcDataStreamBufferComponent approach?
The server sent the LevelLoadRequest rpc by creating an entity with that component and adding a SendRpcCommandRequestComponent, pretty simple.
The client is doing a lot more to send an RPC.
From the client code:

Code (CSharp):

1. private RpcQueue<RpcLevelLoaded, RpcLevelLoaded> m_RpcQueue;
2. m_RpcQueue = World.GetOrCreateSystem<RpcSystem>().GetRpcQueue<RpcLevelLoaded, RpcLevelLoaded>();
3. var rpcFromEntity = GetBufferFromEntity<OutgoingRpcDataStreamBufferComponent>();
4. var rpcQueue = m_RpcQueue;
5. rpcQueue.Schedule(rpcFromEntity[requestSource.SourceConnection], new RpcLevelLoaded());

6. I thought the only way to bring local variables (like rpcFromEntity, LevelFromEntity, levelSingleton) into a job was through a NativeArray. How are they getting passed through into the job without being in a native array?


From the RPCs Documentation:

The IRpcCommandSerializer interface has three methods: Serialize, Deserialize, and CompileExecute. Serialize and Deserialize store the data in a packet, while CompileExecute uses Burst to create a FunctionPointer. The function it compiles takes a RpcExecutor.Parameters by ref that contains:

• DataStreamReader reader
• Entity connection
• EntityCommandBuffer.Concurrent commandBuffer
• int jobIndex

Because the function is static, it needs to use Deserialize to read the struct data before it executes the RPC. The RPC then either uses the command buffer to modify the connection entity, or uses it to create a new request entity for more complex tasks. It then applies the command in a separate system at a later time. This means that you don’t need to perform any additional operations to receive an RPC; its Execute method is called on the receiving end automatically.​

A lot of questions here, not sure what a lot of the terms are referring to.

7. What does "Because the function is static, it needs to use Deserialize to read the struct data before it executes the RPC." mean, why is that required?

8. Is RpcExecutor.Parameters automatically created (the DataStreamReader reader, Entity connection, etc) or does it have do the values have to be explicitly defined somehwere?

9. It says there are 3 methods, Serialize, Deserialize, and CompileExecute, I do not see CompileExecute anywhere, is that method handled somewhere else?


From RpcLoadLevel:

Code (CSharp):

1. [BurstCompile]
2. public struct RpcLevelLoaded : IComponentData, IRpcCommandSerializer<RpcLevelLoaded>
3. {
4.     public void Serialize(ref DataStreamWriter writer, in RpcLevelLoaded data)
5.     {
6.     }
7.  
8.     public void Deserialize(ref DataStreamReader reader, ref RpcLevelLoaded data)
9.     {
10.     }
11.  
12.     [BurstCompile]
13.     [MonoPInvokeCallback(typeof(RpcExecutor.ExecuteDelegate))]
14.     private static void InvokeExecute(ref RpcExecutor.Parameters parameters)
15.     {
16.         var rpcData = default(RpcLevelLoaded);
17.         rpcData.Deserialize(ref parameters.Reader, ref rpcData);
18.  
19.         parameters.CommandBuffer.AddComponent(parameters.JobIndex, parameters.Connection, new PlayerStateComponentData());
20.         parameters.CommandBuffer.AddComponent(parameters.JobIndex, parameters.Connection, default(NetworkStreamInGame));
21.         parameters.CommandBuffer.AddComponent(parameters.JobIndex, parameters.Connection, default(GhostConnectionPosition));
22.     }
23.  
24.     static PortableFunctionPointer<RpcExecutor.ExecuteDelegate> InvokeExecuteFunctionPointer =
25.         new PortableFunctionPointer<RpcExecutor.ExecuteDelegate>(InvokeExecute);
26.     public PortableFunctionPointer<RpcExecutor.ExecuteDelegate> CompileExecute()
27.     {
28.         return InvokeExecuteFunctionPointer;
29.     }
30. }

From RPCs documentation:


10. What is [MonoPInvokeCallback(typeof(RpcExecutor.ExecuteDelegate))] mean?
Why was it not needed in the example in the RPC documentation?

11. Why would you need to "create an entity that holds an RPC"?
I am guessing this is for reasons like when you send data so you can then grab it, like the client did with the level data. If you don't need to grab any data from an RPC I am guessing that you do not need to have this happen, which we don't when we send the RpcLevelLoaded rpc to the server.

12. Why is var rpcData = default(RpcLevelLoaded); rpcData.Deserialize(ref parameters.Reader, ref rpcData); necessary?
It doesn't contain any "values" like LevelLoadRequest does. I am guessing the only data being "deserialized" that the server didn't already know is the NetworkConnectionEntity it came from (parameters.Connection)?

I am guessing we could have made a system that received the RpcLevelLoaded request and added the PlayerStateComponentData, NetworkStreamInGame, GhostConnectionPosition to the NCE by using the ".SourceConnection" but that would have required an entire system instead of the rpc just running on its own.

13. Why are we using AddComponent(parameters.JobIndex, parameters.Connection, new PlayerStateComponentData) instead of AddComponent(parameters.Connection, new PlayerStateComponentData)?
What is up with using index's in this workflow?


I know that is a lot sorry @timjohansson but I am hoping that the answers to these questions "ends" any confusion with RPCs.

 

@timjohansson

A few questions about spawning. But first....

WOW! Great improvements on the spawning flow for player objects and player spawned objects!!! Super appreciate the simplification of workflows from the netcode team! Much easier to understand than extending a partial class and the other methods from before!!
I have been making a guide on how to set up a dots/netcode game and i was able to cut out over 50% of explanations on spawning.

From SpawnSystem in /server

Code (CSharp):

1.         protected override void OnUpdate()
2.         {
3.             if (m_Prefab == Entity.Null)
4.             {
5.                 var prefabEntity = GetSingletonEntity<GhostPrefabCollectionComponent>();
6.                 var prefabs = EntityManager.GetBuffer<GhostPrefabBuffer>(prefabEntity);
7.                 for (int i = 0; i < prefabs.Length; ++i)
8.                 {
9.                     if (EntityManager.HasComponent<ShipTagComponentData>(prefabs[i].Value))
10.                         m_Prefab = prefabs[i].Value;
11.                 }
12.                 if (m_Prefab == Entity.Null)
13.                     return;
14.                 m_Radius = EntityManager.GetComponentData<CollisionSphereComponent>(m_Prefab).radius;
15.             }

1. Why is if (m_Prefab == Entity.Null) return; included in the netcode 0.4 update?
Noticed this line was added. Is this in case the assignment doesn't work a couple lines up?
Line 12&13 above.

Code (CSharp):

1.                 if (!playerStateFromEntity.HasComponent(requestSource.SourceConnection) ||
2.                     !commandTargetFromEntity.HasComponent(requestSource.SourceConnection) ||
3.                     commandTargetFromEntity[requestSource.SourceConnection].targetEntity != Entity.Null ||
4.                     playerStateFromEntity[requestSource.SourceConnection].IsSpawning != 0)
5.                     return;

2. I am trying to understand what each of the 4 conditionals are meant to check for and why all of the 4 are necessary? Does each conditional check for a different possible issue that can arise?
- PlayerStateComponentData is added during loading a level, is this to make sure the level is loaded?
- CommandTargetComponent check is confusing, doesn't that always come with a NCE and if we have an RPC it means we have an NCE?
- targetEntity not equaling Null is to make sure that there isn't already a ship spawned I assume?
- PlayerStateComponentData should not = 0 because it means the ship is spawning, can this happen if the RPC does not get destroyed before the OnUpdate loop is run again?

From ComponentShipGhostSpawnSystem in ShipGhostSpawnSystem in /client

Code (CSharp):

1.         Entities
2.             .WithNone<GhostShipState>()
3.             .WithAll<ShipTagComponentData, PredictedGhostComponent>()
4.             .ForEach((Entity entity) =>{
5.             var state = commandTargetFromEntity[playerEntity];
6.             state.targetEntity = entity;
7.             commandTargetFromEntity[playerEntity] = state;
8.             commandBuffer.AddComponent(0, entity, new GhostShipState());
9.         }).Schedule();

(big fan of ".WithAll<ShipTagComponentData, PredictedGhostComponent>()" being shorthand for "which one is my ship"?)

3. What is the purpose of commandTargetFromEntity[playerEntity] = state? This seems like the reverse of two lines up and I can't wrap my head around why it is necessary. Didn't that assignment already take place?
I understand that you need to assign the client's NCE CommandTargetComponent's targetEntity to the Ship.
Doesn't state.targetEntity = entity do that?

4. What is the purpose of GhostShipState?
I know it is a ISystemStateComponentData, but why is this applied to the prefab?
It seems to be used to find a player controlled ghost that does not have snapshot data and update the NCE CommandTargetComponent targetEntity null... what is that about? I have read about SystemStateComponentData in the ECS documentation but I can't figure out the link for why these types of components are used for Ghosts that have been "deleted" by the server. Why remove the GhostShipState component on the client if the entity is to be "deleted" anyway?

Code (CSharp):

1.             Entities.WithAll<ShipSpawnInProgress>().
2.                 ForEach((Entity entity, in PlayerIdComponentData player) =>
3.                 {
4.                     if (!playerStateFromEntity.HasComponent(player.PlayerEntity) ||
5.                         !connectionFromEntity[player.PlayerEntity].Value.IsCreated)
6.                     {
7.                         // Player was disconnected during spawn, or other error
8.                         commandBuffer.DestroyEntity(entity);
9.                         return;
10.                     }
11.  
12.                     commandBuffer.RemoveComponent<ShipSpawnInProgress>(entity);
13.                     commandTargetFromEntity[player.PlayerEntity] = new CommandTargetComponent {targetEntity = entity};
14.                     playerStateFromEntity[player.PlayerEntity] = new PlayerStateComponentData {IsSpawning = 0};
15.                 }).Schedule();

4. What checks are happening in "!playerStateFromEntity.HasComponent(player.PlayerEntity)" and "!connectionFromEntity[player.PlayerEntity].Value.IsCreated)"?
!playerStateFromEntity.HasComponent(player.PlayerEntity)
so player.PlayerEntity is the Network Connection Entity
playerStateFromEntity.HasComponent(Network Connection Entity), I don't understand what that is doing... it is checking if a component has a component which is an entity....? I don't know if the syntax is getting to me but I can't figure out the logic of that line. Same with !connectionFromEntity[player.PlayerEntity].Value.IsCreated)


From SteeringSystem:

Code (CSharp):

1.             if (m_BulletPrefab == Entity.Null)
2.             {
3.                 var prefabEntity = GetSingletonEntity<GhostPrefabCollectionComponent>();
4.                 var prefabs = EntityManager.GetBuffer<GhostPrefabBuffer>(prefabEntity);
5.                 var foundPrefab = Entity.Null;
6.                 for (int i = 0; i < prefabs.Length; ++i)
7.                 {
8.                     if (EntityManager.HasComponent<BulletTagComponent>(prefabs[i].Value))
9.                         foundPrefab = prefabs[i].Value;
10.                 }
11.                 if (foundPrefab != Entity.Null)
12.                     m_BulletPrefab = GhostCollectionSystem.CreatePredictedSpawnPrefab(EntityManager, foundPrefab);
13.             }

5. Double checking, so all player spawned predicted entities that are prefabs will need to go through this process of GhostCollectionSystem.CreatePredictedSpawnPrefab(EntityManager, prefab) in order to be used?
Way better than the previous approach but wanted to make sure wasn't misinterpreting.


From SteeringSystem

Code (CSharp):

1. var level = GetSingleton<LevelComponent>();
2.             var commandBuffer = m_Barrier.CreateCommandBuffer().AsParallelWriter();
3.             var deltaTime = Time.DeltaTime;
4.             var displacement = 100.0f;
5.             var playerForce = level.playerForce;
6.             var bulletVelocity = level.bulletVelocity;
7.             var bulletPrefab = m_BulletPrefab;
8.             var currentTick = m_PredictionGroup.PredictingTick;
9.             var inputFromEntity = GetBufferFromEntity<ShipCommandData>(true);
10.             Entities.WithReadOnly(inputFromEntity).WithAll<ShipTagComponentData, ShipCommandData>().
11.                 ForEach((Entity entity, int nativeThreadIndex, ref Translation position, ref Rotation rotation,
12.                 ref Velocity velocity, ref ShipStateComponentData state,
13.                 in GhostOwnerComponent ghostOwner, in PredictedGhostComponent prediction) =>
14.             {
15.                 if (!GhostPredictionSystemGroup.ShouldPredict(currentTick, prediction))
16.                     return;
17.                 var input = inputFromEntity[entity];
18.                 ShipCommandData inputData;
19.                 if (!input.GetDataAtTick(currentTick, out inputData))
20.                     inputData.shoot = 0;
21.  
22.                 state.State = inputData.thrust;
23.  
24.                 if (inputData.left == 1)
25.                 {
26.                     rotation.Value = math.mul(rotation.Value,
27.                         quaternion.RotateZ(math.radians(-displacement * deltaTime)));
28.                 }
29.  
30.                 if (inputData.right == 1)
31.                 {
32.                     rotation.Value = math.mul(rotation.Value,
33.                         quaternion.RotateZ(math.radians(displacement * deltaTime)));
34.                 }
35.  
36.                 if (inputData.thrust == 1)
37.                 {
38.                     float3 fwd = new float3(0, playerForce * deltaTime, 0);
39.                     velocity.Value += math.mul(rotation.Value, fwd).xy;
40.                 }
41.  
42.                 position.Value.xy += velocity.Value * deltaTime;
43.  
44.                 var canShoot = state.WeaponCooldown == 0 || SequenceHelpers.IsNewer(currentTick, state.WeaponCooldown);
45.                 if (inputData.shoot != 0 && canShoot)
46.                 {
47.                     if (bulletPrefab != Entity.Null)
48.                     {
49.                         var e = commandBuffer.Instantiate(nativeThreadIndex, bulletPrefab);
50.  
51.                         commandBuffer.SetComponent(nativeThreadIndex, e, position);
52.                         commandBuffer.SetComponent(nativeThreadIndex, e, rotation);
53.  
54.                         var vel = new Velocity
55.                             {Value = math.mul(rotation.Value, new float3(0, bulletVelocity, 0)).xy};
56.  
57.                         commandBuffer.SetComponent(nativeThreadIndex, e,
58.                             new GhostOwnerComponent {NetworkId = ghostOwner.NetworkId});
59.                         commandBuffer.SetComponent(nativeThreadIndex, e, vel);
60.                     }
61.  
62.                     state.WeaponCooldown = currentTick + k_CoolDownTicksCount;
63.                 }
64.                 /*else if (canShoot)
65.                 {
66.                     state.WeaponCooldown = 0;
67.                 }*/
68.             }).ScheduleParallel();

6. Why are we allowed to bring in local variables like playerForce and bulletVeolcity into the job without a NativeArray?

7. What is going on with
if (!input.GetDataAtTick(currentTick, out inputData))
inputData.shoot = 0;?
We already did the "ShouldPredict" check a couple lines up, what is this logic meant to accomplish?
Are we pulling the ShipCommandData from the buffer that is at the current tick and storing it in inputData? If there isn't data at the current tick are we putting inputData.shoot = 0 and leaving all the other data values as null?


From BulletGhostSpawnClassificationSystem:

Code (CSharp):

1. var spawnListEntity = GetSingletonEntity<PredictedGhostSpawnList>();
2.         var spawnListFromEntity = GetBufferFromEntity<PredictedGhostSpawn>();
3.         Dependency = Entities
4.             .WithAll<GhostSpawnQueueComponent>()
5.             .WithoutBurst()
6.             .ForEach((DynamicBuffer<GhostSpawnBuffer> ghosts, DynamicBuffer<SnapshotDataBuffer> data) =>
7.         {
8.             var spawnList = spawnListFromEntity[spawnListEntity];
9.             for (int i = 0; i < ghosts.Length; ++i)
10.             {
11.                 var ghost = ghosts[i];
12.                 if (ghost.SpawnType == GhostSpawnBuffer.Type.Predicted)
13.                 {
14.                     for (int j = 0; j < spawnList.Length; ++j)
15.                     {
16.                         if (ghost.GhostType == spawnList[j].ghostType && !SequenceHelpers.IsNewer(spawnList[j].spawnTick, ghost.ServerSpawnTick + 5) && SequenceHelpers.IsNewer(spawnList[j].spawnTick + 5, ghost.ServerSpawnTick))
17.                         {
18.                             ghost.PredictedSpawnEntity = spawnList[j].entity;
19.                             spawnList[j] = spawnList[spawnList.Length-1];
20.                             spawnList.RemoveAt(spawnList.Length - 1);
21.                             break;
22.                         }
23.                     }
24.                     ghosts[i] = ghost;
25.                 }
26.             }
27.         }).Schedule(Dependency);

From Ghost Snapshots Documentation:

You need to implement some specific code to handle the predicted spawning for player spawned objects. You need to create a system updating in the ClientSimulationSystemGroup after GhostSpawnClassificationSystem. The system needs to go through the GhostSpawnBuffer buffer stored on a singleton with a GhostSpawnQueueComponent. For each entry in that list it should compare to the entries in the PredictedGhostSpawn buffer on the singleton with a PredictedGhostSpawnList component. If the two entries are the same the classification system should set the PredictedSpawnEntity property in the GhostSpawnBuffer and remove the entry from GhostSpawnBuffer.​

8. I am having a tough time making the link between the explanation in the documentation and
"if (ghost.GhostType == spawnList[j].ghostType && !SequenceHelpers.IsNewer(spawnList[j].spawnTick, ghost.ServerSpawnTick + 5) && SequenceHelpers.IsNewer(spawnList[j].spawnTick + 5, ghost.ServerSpawnTick))". What is going on over here with the spawnTick and the + 5 and updating different lists?
The reason we do not need to do this same type of check and clean up for the player spawning is because we spawned the player prefab on the server, not the client, correct?


@timjohansson let me know if you would like me to submit a PR with the answers to all the questions I submitted this weekend commented in line. Super appreciate you taking the time to explain the current functionality.

 

.WithChangeFilter< >() is always triggered even when the value doesn't change when the type has a ghost field. will this be amended in the future?

 

Has anyone been able to build the Multiplayer Asteroids sample?

When I try to build and run for mac:



@timjohansson

 

@timjohansson

I am making a 3D version of the Asteroids sample.

- I have instantiated 4,000 spheres (prefabs)
- if an asteroid goes out of a cube bounds, it is destroyed and a new one is generated

At 400 spheres, they seem to move smoothly
At 4000 spheres, they seem to "jump" to the next location (low frame rate)

Checking out the entity debugger I see that RenderMeshSystemV2 is the issue

And it is taking ~38 ms to complete

1. Am I using the hybrid renderer correctly?
2. Why does the RenderMeshSystemV2 not "get counted" when calculating the frame rate?

 

@timjohansson thank you for the heads up! Will give the static optimization a shot.

1. Does static optimization work with the new Physics package?
- I have added physics shape and physics body to the asteroids
- Will the asteroids "bouncing" off each other still work?

2. What is the best way to interpret the profile to find the "jittering"?
- The profiler modules "Network Messages" and "Network Operations" seem to be empty

 

@timjohansson sorry I am sure I am being dense here but to clarify...

Static optimization is meant for objects that stay at rest (0 velocity)?
- Seems that way from the name and your last comment but I thought because we have position + velocity it means the optimization can be used for moving objects?

If from an position+velocity client & server can calculate next position using static optimization, if client & server are both using Physics, should they not also be able to calculate the objects bouncing of each other as well?
- If that is not the case I am guessing on collisions the server should synchronize each collision with a new position and velocity so static optimization can continue on the new trajectories?

 

1. I think the garbage collection has to do with a warning that appeared when implementing LoadLevelSystem.cs and asking it to update in ServerSimulationSystemGroup "JobTempAlloc has allocations that are more than 4 frames old"
https://forum.unity.com/threads/job...e-more-than-4-frames-old.693394/#post-6433985

- I am implementing full stack traces for leak detection and will check it out to confirm

2. I can't seem to find where the snapshot age is compared to the interpolation delay. I have snapshot age turned on but it doesn't seem to appear on the graphs below. How can I make the comparison?

 

@timjohansson that was actually from the 4,000 asteroids example with a lot of jitter.

I turned on the full stack trace and ran the NetDbg again

It seems like the Snapshot Age literally went off the graph and was no longer visible.

It seemed like the Snapshot age line diverged?

 

@timjohansson

1. So it seems like the remaining option is to use distance based priority to reduce jitter (due to Snapshot delivery) if the Asteroids must be interpolated?
- seems like static optimization and sending initial position and velocity might be complicated and make stability difficult

If the asteroids initial positions and velocities can be sent to the client, and the system of the asteroids bouncing into each other are deterministic (outside of a player shooting the asteroids) is there a way to have the client show what it "expects" to happen unless the server says otherwise?
2. Can the clients "predict" the Asteroids' paths in order to remove the jitter?
- So this way the state that has not arrived yet won't clamp the recent stat?
- And if there is a difference in path (because an Asteroid was actually destroyed) it will correct?

3. Taking a step back, why would a game designer want interpolated asteroids vs. predicted asteroids?
- I understand why we need interpolated "players" (because players are not deterministic) but for deterministic systems is there a reason to not have clients predict the deterministic objects/projectiles/etc?

 

Netcode forum

Who do we have to bug to get this work done?
We've been asking for months. (Is it really that complicated? )

 

Has anyone done any stress testing of NetCode 0.4? I'm currently preparing for it, hope everything goes well and I'm not leaving disappointed.

I'm interested in pretty much any number. Cpu times under load with X amount of connections. Scalability, limits, technical constraints.
Right now I'm at the stage were it works pretty well, I just don't know how well. My first goal is to get 100 stable connections with hopefully not a lot of CPU stress, then 1k and ultimately 10k per server instance. (those connections aren't all in 1 server world, 1 server world has around 4-6 players.)

 

Any plan to make Enable / disable component Entities package feature working out of box into Netcode package when this feature releases? With this feature I will not longer need to create AddedComponents : IComponentData with flags to sync add / remove components between client and server. I can just Enable / disable component and netcode will automatically sync it. I guess need to add one more bool attribute called [GhostComponent(Sync = true/false)] to tell Netcode whether this component need to sync across network when Enable / disable this component.

 

So speaking of physics, what is the recommended way to "hack" working physics prediction in? (until it will be officially supported)
I'm struggling to develop functional workarounds to make it happen, so any advice or guideline would be nice.