game-engine-2d VS builder

I don't think it's unpopular. We need more and better game software, what exists today is unsatisfactory for a plethora of reasons. I'm personally interested in this because I ship Planimeter Game Engine 2D, which comes with client-side prediction standard, and it's the largest pure-Lua game engine on GitHub.[1]

[1]: https://github.com/Planimeter/game-engine-2d

> Another benefit of speculative collision is that I can elminate[sic] the polygon skin/radius on collision shapes. That was necessary to keep shapes separated for the time of impact algorithm. This should no longer be necessary in version 3.0. I never liked this artificial separation of shapes.

Hah! In Planimeter Game Engine 2D, we shrink physics objects by approximating the polygon skin so that we can achieve "pixel approximate" physics.[1]

[1]: https://github.com/Planimeter/game-engine-2d/blob/master/eng...

From what I've found maintaining https://github.com/Planimeter/game-engine-2d is that you should be explicitly checking for nil, separately from checking for false-evaluating values.

We found that this had the added benefit of semantically checking for something that did not exist, versus some contextual "false" value.

I suspect this is a good practice in other languages as well.

Maybe consider https://github.com/Planimeter/game-engine-2d? We have multiplayer with client-side prediction out of the box. Example code is included to demonstrate the ease of networking entity fields, and there is an included payload abstraction for creating networked events.

You can set the tick rate for your game based on your needs as well. And prediction is robust, supporting exceptional packet loss and smoothing over latency concerns for player movement.

Examples in Lua/LOVE:

https://github.com/Planimeter/grid-sdk/blob/master/engine/sh...

https://github.com/Planimeter/grid-sdk/blob/master/engine/sh...

https://github.com/Planimeter/grid-sdk/blob/master/engine/sh...

https://github.com/Planimeter/grid-sdk/blob/master/engine/se...

I remember having to write something similar for Lua, because there was no math.approximately() function and I was dealing with networking floats and comparing values over the wire to predicted movement in 2D space.

https://github.com/Planimeter/grid-sdk/blob/master/engine/sh...

What’s so great about ASN.1 and it’s encoding rules is that anyone writing type-length-value serialization for networking purposes, for example[1], is basically independently reinventing ASN.1 because it’s so fundamentally optimal.

It truly will make you wonder why Protobufs and others exist.

[1]: https://github.com/Planimeter/grid-sdk/blob/master/engine/sh...

We have a partnership with Hathora (https://hathora.dev/) so that our infrastructure can scale globally with high performance so we can provide the best user experience possible despite the realities of playing games over the internet. We also have some big plans around using rollback that we've covered elsewhere that we're cautiously optimistic about.

For multiplayer/server-less games, try Hathora

I cofounded Hathora (https://hathora.dev/) last year and we've been working on making it easier for smaller teams and individual developers to build scalable multiplayer games. We think the serverless model is the simplest approach, allowing you to dynamically provision a new instance of your game server when users or your matchmaker requests a new session.

We made this .io style demo to showcase this approach, and we're releasing the source code and documentation alongside with it.

Hey I'm the creator of https://hathora.dev/ which aims to provide a super simple deployment and scaling experience for session-based games. It's based on containers and can deploy any kind of game server. Check it out and see if it meets your needs!

At Hathora, our mission is to make it easier for developers to build, launch, and scale multiplayer games. One of the core technologies we have built is the Hathora Coordinator, which is our fully managed multi-tenant implementation of a Stateful Router.

Hi there! I started a company this year focused on multiplayer server infrastructure. We also built a multiplayer game framework for Typescript that has gotten 400+ stars on Github in the past few months: https://github.com/hathora/hathora

Would love to connect and exchange notes about multiplayer development -- if you're interested, my email is on my profile.

I've been working on my own realtime networking engine[0] and I think there are a few important points related to network syncing that are not mentioned in this article:

1) Bandwidth. The users internet can only handle so much network throughput, so for fast paced games (where you're sending data to each client at a rate of 20+ frames per second) it becomes important to optimize your per-frame packet size. This means using techniques like binary encoding and delta compression (only send diffs).

2) Server infrastructure. For client-server games, latency is going to be a function of server placement. If you only have a single server that is deployed in us-east and a bunch of users want to play with each other in Australia, their experience is going to suffer massively. Ideally you want a global network of servers and try to route users to their closest server.

3) TCP vs UDP. Packet loss is a very real problem, and you don't want clients to be stuck waiting for old packets to be resent to them when they already have the latest data. UDP makes a major difference in gameplay when dealing with lossy networks.

[0] https://github.com/hathora/hathora

I built a bunch of multiplayer games in the past and am now working on a framework to try and make it easier for others to do so: https://github.com/hathora/hathora