I recently stumbled across a post by Timothee Besset about his plan for an experimental framework for low latency, high fps multiplayer games. TTimo is a games programmer who wrote QRadient and has worked at id software, so knows a bit about what he does.

His post outlines the architecture for a modern FPS game engine, which struck a chord with me. Mostly because at a high level, it’s similar to an idea I’ve had before, a message-oriented game engine using ZeroMQ and its zero-copy message model.

It’s always nice to see your idea validated, especially by someone who knows what they’re talking about. I’m most definitely not a game programmer, despite having tinkered and modded a lot over the years.

I also happened upon a fantastic interview with Edmund McMillen of Team Meat. Whilst being a talk about game development - Edmunds discussion about motivation, career and dealing with people really struck home about a lot of things I have been thinking about recently. Some of those things I’m not ready to talk about, but in terms of game development, the message is clear - keep going at it, the first 30+ things you make are going to be absolute horse shit..

Combined with discussions with one of my coworkers who is writing his own WebGL MMO, Langenium, the interest has definitely been reawakened, for now.

Onwards and upwards

As a result, I’ve been putting a small amount of time into this project over the last three weeks. One of the biggest problems I’ve had working on game-related projects (or really, anything at all) is trying to do too much all at once. You get no reward and make all the wrong design decisions at once.

Instead, I’ve been working at this iteratively - starting with a 2D maze game and upgrading a single thing at a time towards the end goal of a 3D FPS. A high-level of the iterations are as follows:

  • Tile-based 2D maze game using Windows Forms
  • Moving from tiles to continuous coordinate space
  • Move to OpenGL render in 2D
  • Generate 3D geometry
  • Move to 3D
  • Writing Quake 3 BSP parser
  • Move to BSP geometry
  • Quake 3 BSP culling

So currently, I can load and render a Quake 3 map - moving around within the world. I’ve implemented visibility testing using the BSP tree, however have a bug in either that code or my BSP loader which is preventing it from working correctly.

Before I push on - I need to fix that and implement support for Vertex Buffer Objects, as I am currently making an OpenGL call for each vertex, which is very expensive and thrashes the frame rate way down. I’m currently getting 10-15FPS, which is much better than I was expecting for my simplistic engine so far.

The Quake 3 map format is super-efficient and designed so data can be slurped straight off disk into OpenGL buffers. My BSP loader takes the data and interprets it into an object graph - so currently does not do this. The current plan is to implement my own load handler to re-flatten the data internally.

Whilst this is a bit of a waste for now, I don’t have my own BSP tooling and want to keep my engine from being tied to the IBSP format. This is primarily a learning exercise, and I would like to support early versions of the Valve BSP format as well before I’m done.

From here

I’ll be happy with my progress when I can come up with a simple death match game with netcode, similar to Quake 3 - complete with bots. Once I’m done with the game side I want to explore the map ‘compilation’ side of things, BSP partitioning and portal testing.

I’ve never really understood that side of things before now, and conceptually it’s very straightforward - which is a nice refresher. I’m hopeful that as long as I can stay motivated and get past where I’m currently stuck, I can start to play with game ideas on top of my own engine stack.