Multiplayer Game Server Authoritative Logic in Lua
Build the server for a simple multiplayer game in Lua with LuaSocket, where the server is the only source of truth. Players move around a shared 2D arena (and can, for example, collect coins); clients only send what the player pressed, and the server checks every input, updates positions and scores at a steady 20 ticks per second, and sends everyone the new state. That stops cheating: a client can't simply announce that it teleported. Messages use a compact binary format built with string.pack, and a small test client lets you run several players at once. You'll learn non-blocking sockets, framing messages on TCP, binary protocol design, fixed-timestep game loops, and handling slow or disconnected players.
- Estimate
- ~14h
- Steps
- 7
- Completed by
- 0
- Proposed by
- codeseed.app
LuaSocket · Lua
Project roadmap
- 01
Design the binary protocol
~2hWrite PROTOCOL.md: every message is a 2-byte length followed by a 1-byte type and its fields. Client messages: join (name), input (sequence number and pressed keys as bit flags). Server messages: welcome (your player id), state (tick number, then each player's id, x, y and score), and player left. Implement encode and decode functions with string.pack and string.unpack, rejecting messages that are too long or malformed. Done when: every message type survives encoding then decoding in a test.
- 02
Build the non-blocking server
~2.5hCreate a TCP server with LuaSocket that accepts connections without blocking (settimeout(0)) and waits for activity with socket.select. Keep a receive buffer per client, because TCP can split or merge messages: take complete messages out of the buffer only when all their bytes have arrived. Limit the number of players. Done when: several telnet or test-client connections can join, and their messages are decoded correctly.
- 03
Run the authoritative simulation
~2.5hRun a fixed-timestep loop at 20 ticks per second using socket.gettime(), catching up when a tick runs late. Each tick, apply every player's latest input: move at a fixed speed, keep players inside the arena, and handle coins being picked up. Ignore inputs with old sequence numbers and invalid key flags. Done when: movement is the same speed for everyone, and invalid inputs change nothing.
- 04
Send state to every client
~2hAfter each tick, send every client the state message. Send without blocking, keeping a per-client send buffer. If a client's buffer grows too large because it can't keep up, disconnect it instead of letting memory grow. Done when: all clients receive about 20 state updates per second, and a client that stops reading is disconnected.
- 05
Handle disconnects and timeouts
~1.5hRemove a player when their connection closes or when they send nothing for 10 seconds, and tell the other clients with a player-left message. Clients can rejoin with a new id. Done when: closing a client removes its player from everyone else's view within a moment.
- 06
Write a test client and bots
~2hWrite a Lua test client that joins, sends random inputs 20 times a second and prints the state it receives, and a script that starts 20 of them at once. Check the server keeps its tick rate with that many players, and log the tick duration. Done when: 20 bots play at once, and the server stays at about 20 ticks per second.
- 07
Test the logic
~1.5hWrite tests with busted for the protocol (round trips, split and merged messages in the buffer, malformed data) and for the simulation (movement, arena edges, coin pickup), running the simulation without the network. Done when: busted passes.
Ready to build this?
Get a GitHub repo and start building. Your AI reviewer checks each step as you go.
Tech stack