DOTS Netcode Copenhagen updates

There's no point in comparing numbers like "50 players at 60 packet rate" vs "64 players at 30 packet rate" (bf4) vs "100 players at 20 packet rate" (fornite) without knowing the exact games, what they need to replicate, etc.

I would expect the sample to be fairly bare bones, and being able to do 50 players at 60 packet rate is expected. Things start to get a lot harder once you are dealing with a complete game, all the logic that needs to run and all the data that needs to replicate.

Not trying to take anything away from the "50 players @ 60 packet rate" that Joachim stated, but like he said in another thread people are trying to read tea leaves and hang on every word the team says, trying to interpret it in specific ways to support their specific viewpoint, it's getting a bit ridiculous and doesn't do anything good for anyone, not the team working on it or the community waiting for it.

 

Yea, the only difference is that UE is making gigantic steps forward as a state-of-the-art technology every 5 months which is commercially proven for years in triple-A titles, completely free during development and fully open-source, while Unity has in one hand a proprietary unstable and slow runtime mixed with Mono/IL2CPP with astounding and sometimes unbelievable bugs that occurs where you don't expect them to happen, and in another hand almost every core package with the experimental status except Burst (which has its issues as well even released), feature-incomplete stack which is far away from to be usable out-of-the-box for something more or less serious that beyond heavy simulations.

 

And yet here you are, in the Unity forums.

I'm guessing that the reason for this is because maybe you see more "potential" in Unity, if things are done right?

If that's the case, can you clearly state what you would like Unity to do instead of working on shipping DOTS + NetCode?

Because otherwise it seems to me like a lot of people in here are just complaining about the fact that game engines aren't made overnight. And these complaints can't be taken seriously, because there's nothing anyone can do about that

 

It's not a matter of what they are working on, it's a matter of who is working on a particular aspect of the engine, how competent are employees, and how the company investing its resources. In networking, they are making baby steps, again, from scratch. Investition in Multiplay with infrastructure doesn't solve this, you need to invest in the engine's network subsystems respectively to let your wide vector of customers with their projects benefit from it. Internal reshuffling and a few developers are not enough to make it possible. Many people here are overestimating what they will get in the near future, as a result, this will be another failure in their eyes. It's just a matter of time.

Unity is behind of what their customers really need, while they should be at least one step ahead.

 

point me to the place where all the resources and employees currently working on NetCode are revealed, please. I haven't seen it.

You actually got your hands on the NetCode sample release in order to draw those conclusions?

All I hear is "I bet things will be bad". Maybe you're right, but nobody can know at this point. All we can do is wait and see what the NetCode sample offers. And throwing more programmers at a problem is very rarely a good idea

 

You are a bit late, but all the informative conversations were at the last Unite. It's not a secret, you can talk to Tim, Michael or Larus.

I don't, it's only facts from the past 5 years to these days.

 

that's a bet

 

Lol, really things aren't that different in Unreal land Don't get me wrong, I like a lot about UE4 and shipped 2 games on it, but things there also often take years. Can I remind you of how long it took them to finish and ship the Niagara particle system? (

Game engines are complicated beasts, and even more complicated when done at the scale Epic and Unity are working at.

Someone please get this thread back on track and turn down the whine? or bring me some cheese

 

Don't panic guys, It is always quite difficult to publish new package, as you are trying to forecast all possible problems. I think everybody agreed that this new approach make sense. So, let's wait patiently. Every kick to developer "body" will increase possibility of the bug. You should know that working under pressure is not easy. Unity networking team is quite strong, and I trust they will be able to publish package soon. (just 2c)

 

1 - I'm not singling out Unity;
2 - Damn, I didn't know.
My best guess is that my complaint comes from the change of pace: Release with no known issues vs. Release with 18 known issues. Not a few: 18.

I should really use "domain reload times" instead, as compilation is lightning in comparison. How about: Throwing "'fast enter play mode' option" in a volcano and prioritizing .NET Core support for AssemblyLoadContext (and much better performance) above all else? Not everyone wants to or can use DOTS.
Some other things are auto property serialization, a built-in implementation of a serializable dictionary, some package manager stuff (see below), NuGet support, in general embracing .NET.

Let's see:
• URP: Out of preview, yet missing real-time GI and camera stacking. Something I'd like to see is very simple real-time ray tracing: Just prevent light from going through walls.
• HDRP, Shader Graph, VFX Graph: Ok.
• Addressables: Sorry, you don't need to load remote content and just want a synchronous loading API? Sucks for you. It's out of preview, by the way.
• Playables: Sounds a lot like a seven-headed monster, and the documentation doesn't help a lot. Huh. Interesting: The documentation says that one of the things you can do with it is "easily play a single animation without the overhead involved in creating and managing an AnimatorController asset". Hold up. Sounds an awful lot like the legacy animation system. Would it kill to add "get an animation and play it" and other legacy features to the Mecanim API?
• Timeline: It sounds promising and I wanted to try it for a while now, but didn't have the opportunity, mainly because I want to have something to create with it instead of using primitives. I can't say anything about it.
• New Input System: It's fine, save for having an issue and pull request downright ignored for a while due to Unite preparations (a heads-up would barely take any time to write), but a little bit of the boilerplate could be removed by the option of generating action asset classes as MonoBehaviours and looking for them instead of instantiating the generated class in every script that needs it. That would also add a little cleanliness, although it would require support for subscribing multiple interfaces to the same instance.
• Package Manager: The concept is great, but the execution leaves a lot to be desired. The asset store isn't properly supported yet, and the way they worded some stuff implies that it will take a while for it to be, if at all. By "proper support" I mean assets being submitted in package format, therefore requiring assembly definitions, and going in the Packages folder instead of cluttering your Assets folder and source control. Their Git support requires packages to be in the root of the repository and doesn't support Git dependencies.
• New 2D tools, IK package, Cinemachine: Don't use, can't comment.
Bottom line: Unity is releasing a lot of unfinished features. Remember that release is different than preview. Very different.

 

Niagara development stopped for a few years and its design was changed a few times until they released the current version last year. Worth mentioning that Cascade was always production-ready during this and Unity is still playing catching up to Cascade with Particle System even in their 2020.1 release. Also worth mentioning Niagara is considered beta and not ready for production yet.

I find these kinds of threads counterproductive. Everyone wants Unity to give them sneak peeks at what they are working on and assures them they won't complain when schedules shift, but lo and behold complaints start just a few days after the rough release timeline was passed.

There is still an entire release cycle between now 2019.3 beta and 2020.1 full release. Does dots netcode even have a publicly announced 1.0 release date? I get that Unity has a bad track record in terms of network frameworks and releases in general, but I have to say full dots stack 1.0 release is so far away that most of this thread truly reads like someone reading tea leaves

 

Actually, we need Unity to develop a game engine with only one button that says
[build an astonishing & hight performance game and ship it to every majoy store to make money for u, just fill out your bank number here!]

 

agreed.

 

Instead of sneak peeks though we are getting constantly marketed to with features that are not ready. The consequences of that is people get impatient.

 

Well, people should deal with their impatience, not everything is on-demand even in 2019. I'd rather know about what features to look forward to, and get sneak peaks when they're available, than not know about things until they drop. That makes it even harder to plan for the future.

 

I don't know. They also release stuff that isn't ready. Timeline wasn't ready when it was released (and still is awkward to use). URP isn't ready. ShaderGraph isn't ready (or... good), Prog Lightmapper wasn't ready when it was released. Collaborate isn't ready (and they charge for it). Cloud Build isn't ready. Vulkan isn't ready. All the preview stuff isn't ready. But Unity is desperately trying to get us hyped to use them.

Personally it has desensitized me to the point that I have a negative reaction to their marketing stuff, because EVERYTHING they show does not work, and when stuff gets eventually patched and work fine, they are not talked about any more.

So at this point, Unity marketing is, for me, a list of things to avoid.

 

If your definition of "isn't ready" is "it has a few bugs", then please consider giving up on using computers

 

Only if you consider giving up using forums and having conversations.

 

Goodness. Don't get me started on Collaborate. It doesn't have "a few bugs". The beta started on Unity 5.5 and it was released I don't know if on the same version or a few ones later with lots of disconnection issues. After two or so years of tolerating that hot garbage that was still in much of the same state, we finally moved to Git with GitLab, which gives us 10GB for free per project (repository), not Collaborate's free 1GB per user (as in owner, not collaborator).

Speaking of source control, there's their downright dysfunctional Smart Merge/YAML Merge tool which was released in Unity 5 or so and is still broken to this day, and the way Unity reorders stuff for no reason creates a lot of conflicts between completely unrelated things. We so far lost three commits to that because the project owner is too stubborn to make smaller commits, while I was making lots of cleanup commits.

 

When did this thread become the unofficial complain about everything Unity ever did wrong thread? This is a thread about DOTS Netcode updates, and anything beyond that is irrelevant in this thread. Start a new thread if you want to get started on Collaborate or any other package or system you're not satisfied with, they probably don't even belong in the DOTS sub-forum.

I'm very happy that we are getting early access to preview packages, and that we get access to beta features. It takes time to get things stable, and even more so when an engine have millions of users. Frankly I don't care if Netcode has bugs and is somewhat not usable right now, I'd rather get access sooner than later, and we can work with whatever short-comings there are.

But not everyone should work with preview packages, and those that are should take them for what they are. Previews. Anything that's not DOTS Netcode is irrelevant in this thread.

 

When people started mentioning their estimates it began turning into this snowball. Then came I with my stability concerns and that got the ball rolling.

Easy for you to say.

 

Anyone else feel like it's time to either lock this thread or delete like the last half of all replies?

 

Haha, I would have hoped we could refocus this thread back on topic, the insights Ante has given on the progress of Netcode was highly appreciated. But yes, I'd like to forget about half this thread and pretend it never happened.

 

@hippocoder It's time.

 

The easiest thing people can do - pretend that the history does not exist.

 

what

-edit- the post this was in response to was deleted

 

New package is available:
https://docs.unity3d.com/Packages/com.unity.entities@0.2/changelog/CHANGELOG.html

 

Hold On! Does this mean the new Multiplayer Package is also out?

 

No, it's not out yet. The new dots animation package isn't out yet either. Shouldn't be far off now though.

 

it's out, but unofficially (fresh from today)
https://bintray.com/unity/unity/com.unity.animation

You can download it if you go in the Files tab and find the .tgz

 

You can add it to your manifest manually and any updates will start appearing in package manager.

"com.unity.animation": "0.2.16-preview.5 ",

-edit-

should add, i did a bunch of testing yesterday on the previous version of the package (from october) and updated today and while I can see some of the stuff is fixed, there are still a bunch of bugs in this package so I'd recommend waiting to use it.

including crashing the editor when you enter play mode

 

Ah, nice to see a new package version at least, I was only aware of the October package.

 

@PhilSA You are a good logical man who doesn't allow spread of false info. Highly needed and appreciated from another community member! But don't get stock in these conversations either. sometimes this is exactly what people crave and the best way to stop them is not giving it to them and stopping them by just stating the logical and true thing once.

 

*gasp*
https://bintray.com/unity/unity/com.unity.netcode

 

https://bintray.com/unity/unity/com.unity.transport

 

https://bintray.com/unity/unity/com.unity.transport
*SCREAM*

 

In case anyone is wondering: You can install the package by editing your Packages/manifest.json file and adding the following line under "dependencies":

"com.unity.netcode": "0.0.1-preview.6",

 

here are things you can put into your manifest now:

edit: added dots editor to list

 

I'm trying to get the sample from the "Introduction to the DOTS Sample and the NetCode" video running. I copied the code by hand from the video. Unfortunately some parts are cut off and the API has changed a bit. I'm unsure about lines 61-68 (that is just guessing) and also line 87 is unclear:

Code (CSharp):

1. using Unity.Burst;
2. using Unity.Entities;
3. using Unity.NetCode;
4. using Unity.Networking.Transport;
5. using UnityEngine;
6.  
7. [UpdateInWorld(UpdateInWorld.TargetWorld.Default)]
8. public class Game : ComponentSystem
9. {
10.     struct InitGameComponent : IComponentData
11.     {
12.     }
13.  
14.     protected override void OnCreate()
15.     {
16.         EntityManager.CreateEntity(typeof(InitGameComponent));
17.         RequireSingletonForUpdate<InitGameComponent>();
18.     }
19.  
20.     protected override void OnUpdate()
21.     {
22.         EntityManager.DestroyEntity(GetSingletonEntity<InitGameComponent>());
23.         foreach (var world in World.AllWorlds)
24.         {
25.             var network = world.GetExistingSystem<NetworkStreamReceiveSystem>();
26.             if (world.GetExistingSystem<ClientSimulationSystemGroup>() != null)
27.             {
28.                 var ep = NetworkEndPoint.LoopbackIpv4;
29.                 ep.Port = 7979;
30.                 network.Connect(ep);
31.             }
32. #if UNITY_EDITOR
33.             else if (world.GetExistingSystem<ServerSimulationSystemGroup>() != null)
34.             {
35.                 var ep = NetworkEndPoint.LoopbackIpv4;
36.                 ep.Port = 7979;
37.                 network.Listen(ep);
38.             }
39. #endif
40.         }
41.     }
42. }
43.  
44. [BurstCompile]
45. public struct GoInGameRequest : IRpcCommand
46. {
47.     public int value;
48.  
49.     public void Serialize(DataStreamWriter writer)
50.     {
51.         writer.Write(value);
52.     }
53.  
54.     public void Deserialize(DataStreamReader reader, ref DataStreamReader.Context ctx)
55.     {
56.         value = reader.ReadInt(ref ctx);
57.     }
58.  
59.     public PortableFunctionPointer<RpcExecutor.ExecuteDelegate> CompileExecute()
60.     {
61.         return new PortableFunctionPointer<RpcExecutor.ExecuteDelegate>(TestyMcTest);
62.     }
63.  
64.     [BurstCompile]
65.     public static void TestyMcTest(ref RpcExecutor.Parameters param)
66.     {
67.         RpcExecutor.ExecuteCreateRequestComponent<GoInGameRequest>(ref param);
68.     }
69.  
70.     public Entity SourceConnection { get; set; }
71. }
72.  
73. public class GoInGameSystem : RpcCommandRequestSystem<GoInGameRequest>
74. {
75. }
76.  
77. [UpdateInGroup(typeof(ClientSimulationSystemGroup))]
78. public class GoInGameClientSystem : ComponentSystem
79. {
80.     protected override void OnUpdate()
81.     {
82.         Entities.WithNone<NetworkStreamInGame>().ForEach((Entity ent, ref NetworkIdComponent id) =>
83.         {
84.             PostUpdateCommands.AddComponent<NetworkStreamInGame>(ent);
85.             var req = PostUpdateCommands.CreateEntity();
86.             PostUpdateCommands.AddComponent<GoInGameRequest>(req);
87.             PostUpdateCommands.AddComponent(req, new SendRpcCommandRequestComponent {TargetConnection = ent});
88.         });
89.     }
90. }
91.  
92. [UpdateInGroup(typeof(ServerSimulationSystemGroup))]
93. public class GoInGameClientServer : ComponentSystem
94. {
95.     protected override void OnUpdate()
96.     {
97.         Entities.WithNone<SendRpcCommandRequestComponent>().ForEach((Entity reqEnt, ref GoInGameRequest req) =>
98.         {
99.             PostUpdateCommands.AddComponent<NetworkStreamInGame>(req.SourceConnection);
100.             Debug.Log("Hello");
101.             PostUpdateCommands.DestroyEntity(reqEnt);
102.         });
103.     }
104. }

When running it I'm getting the following error:

ArgumentException: Assertion failure. Value was False

Expected: True

Entity.Null passed to SelectEntity().

EntityCommandBuffer was recorded in GoInGameClientServer using PostUpdateCommands.

Edit: Some more hacking. Not sure what I'm doing but at least no more errors.

Code (CSharp):

1. using Unity.Burst;
2. using Unity.Entities;
3. using Unity.NetCode;
4. using Unity.Networking.Transport;
5. using UnityEngine;
6.  
7. [UpdateInWorld(UpdateInWorld.TargetWorld.Default)]
8. public class Game : ComponentSystem
9. {
10.     struct InitGameComponent : IComponentData
11.     {
12.     }
13.  
14.     protected override void OnCreate()
15.     {
16.         EntityManager.CreateEntity(typeof(InitGameComponent));
17.         RequireSingletonForUpdate<InitGameComponent>();
18.     }
19.  
20.     protected override void OnUpdate()
21.     {
22.         EntityManager.DestroyEntity(GetSingletonEntity<InitGameComponent>());
23.         foreach (var world in World.AllWorlds)
24.         {
25.             var network = world.GetExistingSystem<NetworkStreamReceiveSystem>();
26.             if (world.GetExistingSystem<ClientSimulationSystemGroup>() != null)
27.             {
28.                 var ep = NetworkEndPoint.LoopbackIpv4;
29.                 ep.Port = 7979;
30.                 network.Connect(ep);
31.             }
32. #if UNITY_EDITOR
33.             else if (world.GetExistingSystem<ServerSimulationSystemGroup>() != null)
34.             {
35.                 var ep = NetworkEndPoint.LoopbackIpv4;
36.                 ep.Port = 7979;
37.                 network.Listen(ep);
38.             }
39. #endif
40.         }
41.     }
42. }
43.  
44. [BurstCompile]
45. public struct GoInGameRequest : IRpcCommand
46. {
47.     public void Serialize(DataStreamWriter writer)
48.     {
49.         writer.Write(SourceConnection.Index);
50.         writer.Write(SourceConnection.Version);
51.     }
52.  
53.     public void Deserialize(DataStreamReader reader, ref DataStreamReader.Context ctx)
54.     {
55.         SourceConnection = new Entity {Index = reader.ReadInt(ref ctx), Version = reader.ReadInt(ref ctx)};
56.     }
57.  
58.     public PortableFunctionPointer<RpcExecutor.ExecuteDelegate> CompileExecute()
59.     {
60.         return new PortableFunctionPointer<RpcExecutor.ExecuteDelegate>(InvokeExecute);
61.     }
62.  
63.     [BurstCompile]
64.     private static void InvokeExecute(ref RpcExecutor.Parameters parameters)
65.     {
66.         RpcExecutor.ExecuteCreateRequestComponent<GoInGameRequest>(ref parameters);
67.     }
68.  
69.     public Entity SourceConnection { get; set; }
70. }
71.  
72. public class GoInGameSystem : RpcCommandRequestSystem<GoInGameRequest>
73. {
74. }
75.  
76. [UpdateInGroup(typeof(ClientSimulationSystemGroup))]
77. public class GoInGameClientSystem : ComponentSystem
78. {
79.     protected override void OnUpdate()
80.     {
81.         Entities.WithNone<NetworkStreamInGame>().ForEach((Entity ent, ref NetworkIdComponent id) =>
82.         {
83.             PostUpdateCommands.AddComponent<NetworkStreamInGame>(ent);
84.             var req = PostUpdateCommands.CreateEntity();
85.             PostUpdateCommands.AddComponent(req, new GoInGameRequest {SourceConnection = req});
86.             PostUpdateCommands.AddComponent(req, new SendRpcCommandRequestComponent {TargetConnection = ent});
87.         });
88.     }
89. }
90.  
91. [UpdateInGroup(typeof(ServerSimulationSystemGroup))]
92. public class GoInGameServerSystem : ComponentSystem
93. {
94.     protected override void OnUpdate()
95.     {
96.         Entities.WithNone<SendRpcCommandRequestComponent>().ForEach((Entity reqEnt, ref GoInGameRequest req) =>
97.         {
98.             PostUpdateCommands.AddComponent<NetworkStreamInGame>(req.SourceConnection);
99.             Debug.Log("Hello " + req.SourceConnection);
100.             PostUpdateCommands.DestroyEntity(reqEnt);
101.         });
102.     }
103. }

 

Did you look in the Documentation folder of the netcode package yet? There is a quick start doc there which I think quite closely resembles the example Tim did on stage.

 

Thank you for the hint!

I got the example from the "quickstart.md" running.
However I had to add the component "MovableCubeComponentAuthoring" to the prefab, "update component list" and select "MovableCubecomponent.PlayerId" in the drop-down first:


Also for me it only works if I disable Burst:

 

Weird. I have it working with burst enabled.

 

It is now working for me as well - after restarting Unity.

 

When do you guys think we'll see a full release of the preview package in the package manager?

 

0.2.0-preview.4 doesn't appear to work on Linux—it complains about a missing DLL, and the `libnetwork.bindings.so` file appears not to exist in the package (when compared to the old transport package from the multiplayer repository). Copying in that file manually seems to work as a hack fix.

 

The packages are available now in the package manager.

Remember that these are the first experimental package release of both the netcode and animation packages, so please do not expect either of them to be production ready or be a representation of their final state.

@Latty some transport binding were omitted, and will be added back in for the next release coming shortly.

 

@MartinGram (2020.1a014) I'm forgetting something?

 

add "com.unity.animation": "0.2.16-preview.5", to your manifest.

 

Looks like 2019.3 has been released....maybe we'll get the new FPS drop soon too?

 

2019.3.0f1 is Release Candidate 1, not a full release.