• Advertisement

JM-KinematicSoup

Member
  • Content count

    15
  • Joined

  • Last visited

Community Reputation

2 Neutral

1 Follower

About JM-KinematicSoup

  • Rank
    Member

Social

  • Twitter
    @kinematicsoup
  • Github
    kinematicsoup
  1. Snapshot Interpolation

    Glenn's articles are a good place to start. Multiplayer is such a complicated topic that even in all his blog posts he only covers most of the basics. We are using snapshot encoding as well because we need to do dynamic physics, and it's easier and much more reliable to reconcile from a single authoritative source. We can add a deterministic lockstep method later, however we will still have an authoritative sim running somewhere. We also will need to be able to sync in at any point without rerunning the sim from the beginning.
  2. Snapshot Interpolation

    Yes. In our case we run network receives at a different rate than sends as well in order to process RPCs as fast as possible. In our case we use previous packet data to predict current state, just due to the number of objects we are describing. In that case we need to packets to always be in-order and guaranteed to arrive. If order does not matter, dropped packets also won't matter and you don't need RUDP, regular UDP will suffice. True. I should have qualified that better: It is possible to each user to experience exactly the same simulation, just not at the exact same time.
  3. Snapshot Interpolation

    These are excellent points. Latency is actually a lot more complicated than people realize. Not only do you have a server loop, but you'll have encoding time and other factors that can sneak a millisecond in here and there. The approach we took was to run two threads: A game loop thread, and an network thread. All the serialzation/encoding happens in the networking thread, so we have a pretty reliable loop latency. Typically we send data about 2-3ms after the logic loop has completed. When the encode runs longer, we track the extra ms and try to catch up in subsequent frames that finish earlier. This helps to smooth out the arrival of packets on the client-side. We do something a bit goofy, but works for us. The network library runs as independent Hz from the main loop, and further can receive at a different Hz than it sends. This means that if we set the main loop to 60 Hz, we can run the networking send loop at 20 Hz, so you get the precision of 60 Hz but the data reduction of fewer packets. The network receive can still happen at 60 Hz, which means you can receive RPCs fast enough to have them be meaningful in the game logic. http://kazap.io runs at 30 Hz but does feel quite responsive despite being a web game that uses websockets, and has a relatively low update rate (okay, I consider 30 Hz low...). Part of the reason it feels responsive is we use local input and extrapolation to mask the extra latency. Lag manifests differently when you use extrapolation. Instead of a delayed response, you get sluggishness, which is preferable in some cases. We use UDP and TCP. TCP has a lot of drawbacks but is otherwise fine for development, and when your frames encode to < minimum MTU it does behave a lot like an RUDP library. The key thing with making sure sends go out quickly using TCP is to turn off Nagle (set by using TCP_NODELAY). To address that last point, which I think is the most important: Synchronous multiplayer is an illusion - focus on the appearance of synchronization, not the accuracy of it. Most of the time you'll be close enough that it won't be an issue, anyway.
  4. Hi all, My team and I are working on a feature video to cover everything Scene Fusion is capable of. It covers almost all of the features in Scene Fusion to date. Other features are coming over the next 3-4 months. We will be introducing several new capabilities soon such as an revamped API so you can choose what gets synced an how, a raw C# and raw C++ API, and Scene Fusion for Unreal beta.
  5. ZLib compression from UE4 to Boost ?

    Oh BTW, have you tried using LibLZMA from the 7-zip project instead of the zlib library?
  6. Snapshot Interpolation

    We used a type of extrapolation for a game we created. It works well on slower games and masks latency effectively: http://www.kinematicsoup.com/news/2017/5/30/multiplayerprediction
  7. ZLib compression from UE4 to Boost ?

    More importantly, it is probably actually expanding the data.
  8. Hi all, We do these internal game jams from time to time. One of us created a multiplayer game that we had enough fun playing in the office that we thought we would just stick it in a browser for the world to enjoy, and just use ads to pay for it's running costs. The game is kazap.io. I thought I would share with you how we handled making the motion smooth and keeping a 'snappy' feel. Here is the video, and there is also a blog post with code!
  9. Multi-player level creation

    You are thinking about MaxPlay. I have quite a bit of background knowledge on them. They wanted to take on Unity and Epic, which was not a small task, and the funding did dry up for various reasons. We are looking at UE4 support right now. I estimate that it could take up to a year for us to get it to where it currently is with Unity (ie. we support all built-in components as well as custom components - properties all sync, and it works in tandem with source control for code/asset changes). However, we can at least get the basics in place in a matter of 6-10 weeks. Our biggest problem is just getting interest from developers. I would love to have 20 studios in the beta to help us focus on the pieces we need to focus on.
  10. Multi-player level creation

    Hi all, I have been working on a project that enables multi-player level creation (ie. multiple level designers work together in real-time). Right now we have it working for Unity. Here is a video of it in action: This isn't a new idea, and has been tried before. The idea is that you get lots of benefits from working this way: 1) No more scene merging/conflicts. 2) People can see and react to each other's work immediately, they can iterate on things instantly. 3) Much easier for the lead designer to be active in the work, supervise, and provide feedback - camera following is actually being used as a supervision tool. 4) It's actually much more fun to work this way, so people are more motivated and work faster. So here is a question: Has anyone worked with a system like this in the past? What did you think of it?
  11. New to the forum, Hello everyone!

    Yes we have a few tutorials, and some speed builds. We have a few more blogs and whatnot we would like to put up that we think will be helpful, though youtube is mostly going to show what we are working on.
  12. New to the forum, Hello everyone!

    It's a lofty one, for sure. We do have an advantage in that we've figured out a way to use about 2-5x less bandwidth than things like UNET. Also, we are actually building our system so it can be used by any game engine, even homebrew ones, and by people who want to use frameworks like monogame. Scene Fusion is in a similar boat: Unity support is first, other engines are in the pipe.
  13. Unity has put up an official release of EditorXR (formerly EditorVR). https://labs.unity.com/article/editorxr-and-scenefusion-update If you haven't tried it lately, you should. This release is actually very good,
  14. Hello everyone, I'm looking for some input. We created a tool called Scene Fusion to enable real-time collaboration while doing gamedev in Unity. In effect, it will replicate any scene changes one person performs for everyone else connected to the session. It works well, and we as well as our customers using it notice a drastic speedup getting work done, especially when building large complex levels. One limitation we have is that we can't support every single plugin and asset out there, so what we opted to do is provide an API that allows game developers to do that work as required. My question is: How many if you out there actually end up having to modify an external plugin/tool in order to get it to work with your project?
  15. New to the forum, Hello everyone!

    Hi Everyone! I'm new to this forum, though I am active in the general gamedev community. I'm with a company called KinematicSoup. We make something called Scene Fusion - a real-time collaboration system for Unity (and other engines soon!). Our *real* mission is to build the best multiplayer system the world has ever seen... We have a youtube channel here: https://www.youtube.com/kinematicsoup/ Cheers!
  • Advertisement