Today, online multiplayer games are always centralized. This means the barrier to create a good multiplayer game is pretty high - it would require your own game servers to host game lobbies. ZK Proofs shared across a p2p network would allow clients to directly interact with each other and validate player moves according to the game logic correctly.

(Watching the demo first before reading this is recommended)

With Footsteps, I wanted to give a try at a (near) real-time multiplayer game (there's a delay of ~3 seconds because of proof generation and verification when it comes to revealing player moves). So every 5 seconds, a proof of all your moves in that time is generated and shared - for other players to verify - and also get a hint of where you are (50% of your moves are revealed).

This game eliminates the need of game servers and introduces sybil resistance to create bot free p2p lobbies.

Players can log onto the game. When their client connects to another client via p2p, SelfBackend verifier urls are shared between each other so that they can proof that they are each human. Then you can play as normal in the game. Watch the demo!

The game client for each player is divided into 2 parts. The first part features a rust server hosting a libp2p node, a websocket server, and a risc0 prover and verifier for the game logic. The second part is a nextjs web app with the actual game visuals and a Self Protocol backend verifier and QR Code display.

The frontend web app takes in player movements and relays them to the rust web server for it to generate the movement zk proofs. Each time a proof is generated (about every 5 seconds), other connected libp2p nodes (in the lobby) verify the proofs. If the proof is invalid, the rust server will have to rollback its position to what it was before that invalid move.

The circuit itself features a Bevy ECS world, where a player can freely move by one space per key input. The circuit receives a list of key inputs that were inputted in those 5 seconds (I removed collision decrease to increase proof generation & verification time), and then reveals the middle 50% of the player's moves without revealing the rest. This is what is emitted to the other nodes.

Self Protocol was integrated into the project to verify that players are indeed humans, are above 18 years of age, and are not on the OFAC list. This is important to ensure that players know who they're playing with. In a lobby, all players have the same set of disclosures and requirements. They each run a verifier, so that, when a new player joins the lobby, they first ask that new player to prove that they match the criteria to enter, using an existing lobby member's verifier, and vice versa, the joining player would get to know that other players in the lobby are valid. In the case that a proof is invalid the existing p2p clients would disconnect from the player and reject any requests to reconnect.

This decentralized player verification system is used in this project (and possibly other serverless games in the future), to ensure that bots don't flood lobbies.

Unlike other ZK games, this one isn't turn based but rather real-time, where proofs of movement are batched into 5 second intervals. I was excited to discover how this worked because it meant that we no longer need game servers to validate game logic but rather can just send proofs of movement to other players in the lobby, without revealing my location, and validate that those moves were right.

On top of that, for serverless games, in the future, it would become easy for bots to just join game lobbies (since connecting to other players is done via p2p). Hence having a zk proof of your passport and verifying it with other players would significantly help in sybil resistance in game lobbies.

Unfortunately, while building my project, I found out Risc0 isn't directly supported on windows, which is where I wanted to run my bevy (a rust game engine) game as a web app. I got the demo to work on WSL, but then I wouldn't be able to present the multiplayer part. So instead, I switched to a nextjs game app in the browser, which would communicate with a rust websocket server to generate our proofs, and communicate and verify other players proofs.

I also didn't have enough time to develop a shooting / flashlight system which would kill / spot another player, but ideally, if a player decides to shoot, they'd request a proof from each player that shows that they were within the flashlight's path or not, in which they die or don't. This also allows other players to keep their location private.