Building a More Efficient NetworkTransform

I’ve been using Unity’s free networking solution, UNET, in an RTS. On the whole, it works, but it doesn’t work especially well. Since UNET has to support many different types of games, the choices made by the developers lean towards versatility and flexibility, rather than efficiency.

Case in point: the NetworkTransform. It supports many things out-of-the-box, including interpolation, rigidbodies, and variable send rate, but it makes tradeoffs in the efficiency department. Every time it syncs a transform, it’s sending position and rotation uncompressed. With 3 floats for position and 3 floats for rotation, that’s 24 bytes every time a sync happens. The entire Unity networking library is open source, so you can analyze the NetworkTransform yourself.

There’s two reasons for wanting to reduce the bandwidth of the NetworkTransform:

  1. The Unity Matchmaking Service enforces a per-second bandwidth limit of 4kb in pre-production mode. 4096/24 is about 171. Assuming 10 updates a second, thats means only 17 NetworkTransforms syncing at once - with no other traffic at all.
  2. Reducing the amount of bandwidth allows us to push the send rate higher than 10x a second, reducing the amount of interpolation needed along with the perceived latency.

A couple of notes before we get started. First, a lot of this article is based on Glenn Fielder’s (Gaffer’s) snapshot compression article, which is applicable no matter if you’re using Unity or not. I’m going to be explaining a few concepts from the article, for completeness, but you should familiarize yourself with it before reading on.

Second, you should be familiar with bitwise operations. Since we’re trying to save as much bandwidth as possible, we’ll be hand-packing bits.


Delaunay Triangulation for Terrain Generation in Unity, Part 2

Island in Wasteland Dogs

This post is a companion post to my previous post on using delaunay triangulation in terrain generation. In that post, I covered some of the implementation details involved in taking a Triangle.Net mesh and transforming it into a Unity3D mesh.

In this post, I’ll talk about a couple more things I did with the terrain:

  • How to space out the triangulated points better
  • How to find the height at an arbitrary point in worldspace


Cool Things I've Been Doing With Unity Shaders

In-development screenshot of the RTS project in Unity.

I’ve been on an art kick working on my most recent side project, an RTS made in Unity. In this post, I want to share some neat things I’ve been doing with shaders.

Note that this is an area I’m still exploring and learning in. These are just the results of some of my first experiments. If you have ideas on how to improve them, please leave me a comment at the end of the post.


A Curious Case of Deadlock

Some knowledge of Swift and thread synchronization is required ahead.

Normally, on this blog, I write about games and game development. However, most of my time is spent on working on something else entirely; by day, I’m an iOS app developer at a big company you’ve probably heard of.

Recently, our team ran into a really interesting deadlock. I was working on writing a threadsafe cache implementation - a cache only one thread can read from, or write to, at a time. Seems like by-the-book multithreading. Except… well, it wasn’t, of course.


Delaunay Triangulation for Terrain Generation in Unity

Island in Wasteland Dogs

Lately, I’ve been working on a multiplayer dogfighting game in Unity. While I could have just had players fight over a flat blue ocean, I felt like the levels needed something more. Inspired by my previous experiments in terrain generation, I generated a perlin noise heightmap, and then created a mesh using regularly spaced points.

However, I felt like the terrain was… well, rather bland. I went searching for inspiration around the internet, and the one that really stood out to me was Woodbot Pilots. In some places, their triangles are huge, suggesting slabs of rock and towering cliffs. In other places, small triangles hint at crevices and finer detail. I didn’t fool myself into thinking I could achieve such a detailed result with procedural generation, but perhaps I could get close by using irregularly-spaced points, rather than points on a grid.

Back in Feburary 2015, I used amitp’s tutorial on voronoi cells to create terrain for a small tactics game. The terrain in that game looked kinda like what I needed, but in 2d. I set about trying to use voronoi cells to procedurally generate a mesh in Unity. In this post, I’ll go over the initial part of generating the triangulation and translating that into a mesh.


Texture Packing for Fonts

Animated gif of the font packing

In a previous post, I covered the guts of the dropdown console I wrote for my very simple FPS. However, I didn’t mention any techniques on how to actually render the console. When I was first implementing this, it didn’t seem too bad - just throw up a quad with some text on it, right?

In actuality, text rendering turns out to be a fairly non-trivial task. My first attempt loaded each character as a single texture, and drew one quad/character at a time. However, I quickly ran into performance problems with this - even with just a few hundred characters on screen, there was noticeable lag.

The solution to my problem was to pack all of the characters into one texture, and then batch the draw calls together by line. This reduced hundreds of draw calls to just ten or twenty. In this post, I’ll cover the algorithm I implemented to pack multiple textures into one.


Implementing a Console Callback System in C++

Dropdown console in SpiderGame

Back when I was writing a terrain generator in C++, I used this library called glConsole to put a quake-style dropdown console into the project. By a “dropdown console”, I mean the thing in the screenshot above - a place to execute scripts from inside the game. Basically, if I typed this in the console:

wireframe 1

I wanted to execute this in C++:

void Renderer::setWireframeRendering(bool value) {
    this->wireframe = value;

However, this wasn’t possible in glConsole. While it did most things pretty well, the one thing it could not do was bind member functions - functions which are part of a class. You could bind free functions and static functions, but not methods. Lately I’ve been working on a very simple first-person shooter using C++ and no game engine. I wanted something like glConsole, but without the glaring downside. Plus, I was writing the game from scratch for a reason - why not write my own console?

In this post, I’ll explain my approach to implementing a callback system which stores functions and executes them at a later date. My goals for this system were:

  1. Member functions should be supported.
  2. You should be able pass in any method/callable object to be called at a later date.
  3. It should be (at least somewhat) typesafe.


On the Zen of Devil Daggers

Devil Daggers.

Devil Daggers is a mystery of a game: one big contradiction. It’s simple but complex, chaotic but calm, beautiful but horrifying. It’s a game that, at first glance, isn’t worth writing about - but here we are.

For the uninitiated, here is a brief description of Devil Daggers.

  • It is a first person shooter.
  • You have two weapons, a rapid-fire spray and a shotgun-like blast.
  • The entire game takes place on one circular platform, which shrinks over time.
  • There are different enemies. They spawn at preset times, in preset configurations.
  • The goal of the game is to live as long as you can.
  • Touch one enemy, and you die.
  • If you die, you start all over again.

Let’s lay out Devil Daggers’ crimes, the reasons for which it should absolutely not capture anyone’s interest. First off, The enemies are too predictable. Circle strafe enough, and it seems as if they’ll never hit you. The stages, too, are dreadfully repetitive. The same enemies spawn at the same times, all the time. Then, every time you die, you have to do it all over again! Same repetitive thing, over and over. It’s only made worse, of course, by those leaderboard replays; if you can watch others do it, what’s the point? You can just reproduce exactly what they do!

Well, all that’s true. So why’s it so damn compelling?


Global Game Jam 2016 Retrospective

Picture of the team. There are 2 extra people (advisors?) in the picture.

Last weekend, I attended my second Global Game Jam. Last year, down in North Carolina, I went with a friend and we ended up working with just him, at his apartment. This time, the circumstances were entirely different; I’d moved to the Seattle area just days before, and I knew no one in the area. I knew it’d be a challenge, but I was resolved to head to the Academy of Interactive Entertainment alone and find a team.

Wow, am I glad I did. After 48 hours, only 8 of which were sleep, we made a game that I think all of us were proud of. Here’s a short article detailing what I think went right and went wrong.


Lavasoft Web Companion

A while ago, I noticed that my default search engine and new tab page in firefox had been changed to Bing. I dismissed this as some stupid thing I had accidentally done, reset both to the defaults, and went back to whatever I was doing.

However, a more pressing problem soon presented itself: Unity (the game engine) kept crashing on start. One of the first links I chanced upon when googling the problem mentioned a program called Lavasoft Ad-Aware, and the gears instantly clicked. I must have accidentally installed some crapware while installing another program! That would also explain the bing crap. I looked around, and found a program I definitely didn’t install called Lavasoft Web Companion. I uninstalled it, and all the Bing stuff went away - but Unity kept crashing on start.