August 28 – Where I’m At

Several months ago, I had a conversation with a colleague about game development. I was expressing to him some concerns about my ability to finish Gateway in a reasonable amount of time, and whether or not the game would actually be fun. He pointed out that many games ship uncompleted, and that companies release content and patches later on. Insightfully, he also suggested that I develop a vertical prototype of my game to get some feedback before releasing it.

A vertical prototype is a narrow slice of a game that is fully playable. An example in my case would be a single mission. Although the main game mechanics (as well as several missions and other features) were already implemented, some of them needed to be upgraded or more thoroughly tested. A vertical prototype would be a great way to focus my efforts, so I made up my mind to develop one for Gateway and have some coworkers play-test it for me.

After that conversation, I spent the next several months fixing bugs and sharpening up some game mechanics. I designed a five minute mission specifically for testing purposes. It included a mix of my favourite dialogue and visuals from the actual campaign. A lot of effort went into improving or redoing some existing art assets, too, that I felt weren’t up to snuff. (My friends who develop game art professionally were an immense help here—they provided me with a ton of useful advice as I reworked my models and textures. Thanks folks!)

I scheduled play-testing for August 26th. Listed below are the tasks I aimed to complete before then. Each task was assigned a difficulty level. Not all of them were completed, but the essentials were done.

  • correct a major bug in the particle system (4)
  • rework the turret animation system to something more realistic (2)
  • model and texture new NIA and ISC cruisers and turrets (18)
  • correct the appearance of the first-person shield effect (1)
  • make the game engine fully adhere to an OpenGL 3.2 core profile (2)
  • rework the GUI system to look nicer and be bug-free (3)
  • add zoom blur effect when boost is activated (2)
  • correct a problem with missile collisions not being detected (1)
  • improve handling of in-game camera (1)
  • add debris assets (space junk, asteroids, cruiser chunks, etc.) (3)
  • correct obstacle avoidance AI (unknown, maybe 2)
  • create NIA/ISC cruiser collision geometry (1)
  • fix an issue with the turret shields not rendering properly (1)
  • optimize laser bolt light generation (2)
  • fix an issue with the targeting arrow (2)
  • discard non-colliding candidates faster during collision checks (1)
  • change laser bolts to use batch rendering (2)
  • texture the new cockpit model (17)

Last week, I demoed Gateway and my coworkers were thrilled to finally try the game I had been talking about for so long. It was very well received, and most of my colleagues had helpful suggestions to make it even better. Here are some of the most notable issues that were identified:

  • targeting arrow is sometimes misleading and still needs a bit of work
  • “target destroyed” and “mission complete” feedback indicators would be useful
  • star fly-bys need to be brighter to indicate player speed
  • HUD speed indicator would be good, too
  • adding a “reverse-flip-over” maneuver to reverse direction would be very useful

During testing, something interesting happened several times: my colleagues became upset that the player didn’t take any damage when colliding against large objects like gates, cruisers, or asteroids. What’s funny about this is that I disabled large-object-collision damage on purpose to make things easier, but everyone seemed disappointed by this. That surprised me, and I have two guesses for why everyone reacted this way: (1) players expected realistic mechanics, i.e., collisions should cause damage, and (2) players might have felt that their careful maneuvers were meaningless if there was no penalty for failing to execute them properly. (This was an eye-opening moment for me. I hadn’t spent a lot of time thinking about these kinds of implicit rewards.)

There were some positive points as well:

  • players found destroying things (turrets, gate coils, fighters, etc.) very satisfying, especially when destroying several of these in quick succession
  • the sleek look and feel of the game made it very pleasant to play in general
  • in-game audio was immersive and well-received

Overall, everyone had a positive experience, which was a bit of a relief for me. Until that day, I really had no idea if my game was fun or not. Also, it was incredibly helpful to get so much detailed feedback. Thanks, everyone!

Of course, I can’t just talk the talk after all that. Here are some screenshots from the vertical prototype mission.

My next task is to tackle the improvements that my coworkers suggested. It’s a real confidence booster to get this kind of feedback. Not that I ever really doubted it, but this experience has reinforced my belief that Gateway is a game not only worth developing, but worth playing, too.


Effective Level Editing

A few years ago, I completed a project called Dactyl. It was a 2D asteroids-shooter-type game. There were 25 hand-generated levels populated with mines, asteroids of various types, useful equipment, and automated turrets.


To visualize each level before I implemented it, I used graph paper and a pencil*. Once I felt a level was complete, I plugged the object coordinates into a text file, and then fed the file into the Dactyl engine. And pop, out came a new level.

This approach definitely wouldn’t work in Gateway. The size of each level (up to about 20km!), especially considering the differences between, say, the 10 meter fighters and the half-kilometer battle cruisers, made drawing complex scenarios to scale next to impossible. Making changes to level designs would also be painful: erasing a group of 30 fighters and shifting them over a kilometer would quickly eat away at my eraser and my sanity. Besides, my hands aren’t steady enough for that kind of nonsense.

Dactyl levels were sketched out by hand.

Dactyl levels were sketched out by hand.

The solution for Gateway was to build my own level editor.

I’ll admit that I didn’t spend a lot of time investigating existing solutions. I was (pretty) sure that there was (probably, maybe) some level editor somewhere that would offer the right parameters and would allow me to drag, drop, and configure all of the game entities I wanted onto the Gateway playing field, but I really didn’t feel up to downloading and trying various existing editors only to find that each one was missing a crucial feature.

Ah, yes…implementing things from scratch rather than using existing solutions. I often do this with smaller projects for a number of reasons: (a) I believe in doing everything yourself at least once, (b) it’s often more fun, and (c) I can usually whip up something small in less time than it would take for me to learn to use an existing tool. (I recognize that this is a twisted combination of both laziness and diligence.) I also (d) like to be intimately familiar with the code I use, and this is easiest when it’s code that I write myself. Additionally, my own level editor could be completely customized for exactly what I needed it to do. (Besides, by the time I started considering developing my own, the back burners in my brain had already fired up and began doing the work for me. I think somewhere back there I knew very early that I’d have to write my own.)

I intentionally wanted to keep my editor’s feature list as minimal as possible, since I’d probably only use it specifically for Gateway (although it could be altered without much effort for similar games) and didn’t want to spend too much time adding features that weren’t absolutely necessary. I just wanted the bare essentials for designing levels quickly and easily…so, there were hard choices to make.

C# .NET would be an ideal choice for this project, since I’ve worked with it extensively on a variety of projects. This meant that graphical user interface elements like buttons or text boxes wouldn’t be a problem. The next thing I had to consider was whether or not I wanted a 2D or a 3D representation of the world in my editor. There were pros and cons to each.

Advantages of a 3D level editor:

  • Entities could be moved around the environment and viewed from the player’s perspective
  • Everything could be viewed as it would appear in-game: for example, depth or height would be easier to determine than it would be in a 2D, top-down view

Disadvantages of a 3D level editor:

  • Harder to implement than a top-down representation in terms of entity selection (picking), transformations, etc.
  • C# .NET does not feature built-in 3D support and would require using GLControls or something similar (I wasn’t adverse to this, but it was another layer of complexity I wasn’t sure was really necessary)

Ultimately, I decided to go with a 2D representation simply because the style of the game didn’t place a whole lot of importance on an object’s height or altitude within the game; the flight controls are more like flying an aircraft than a true 6DOF fighter (I did this to make the game simpler and more accessible to players). Thus, the world could fairly easily be represented in a top-down fashion. Of course, objects exist at many different “altitudes” in the game, but not to such a degree that it was critical that this be represented clearly in a level editor intended solely for myself.

Next, there were issues of scale to consider. I wanted to have missions that could potentially be around 20km by 20km in size. I also wanted everything in the editor world layout to be visible all at once without zooming or scrolling. Ultimately, I decided on a layout pixel size of 600×600, with every pixel being equal to 30 meters in real space. That was more than precise enough for my needs and resulted in a playing field of 18km by 18km.

My choice of scale had one unfortunate implication. The smallest unit of size that could be represented in my editor was 30m (1 pixel), but the fighters in Gateway are around 10 meters long, which was one-third of the smallest visible unit in my editor. Cruisers, being around 600 meters in size, could be represented to scale with 20×20 pixel sprites, but fighters posed a problem. I decided to simply make the fighter sprites larger than they would be in real space by several pixels in each direction, to allow easy visualization and selection with the mouse.

scale issues

Without some changes, the fighter sprites would absolutely be too minuscule to determine orientation, select with the mouse, or even see properly.

Next on the list was to decide the kinds of features I wanted to support in terms of building worlds. Tools like selection, translation, and rotation were essential. A ‘snap’ functionality would be immensely useful in terms of both moving (snap to grid) and rotating (snap to angle). Since I’ve used Blender a lot, I decided to support Blender-style keyboard shortcuts (which often don’t require modifier keys like shift or control) to make things familiar and faster: ‘A’ to toggle selections, ‘G’ for grab, ‘R’ for rotate, etc.

After about two weeks, I had a fully-working editor. It only had a minimal set of features, but that was all I needed.


Level-building in progress. The player and a few wing mates are spawned far away from the action. The editor is just as much fun to use as it was to implement!

Team colours are represented by the highlights around objects. A grid in the background is used to determine distances. A few other tabbed panels are used for scripting music, dialogue, etc., and basically just contain multi-line text boxes.

Developing a level editor has been a very interesting and exciting experience for me. If anyone has experiences or stories working with level editors (including their own), I would love to hear about them in the comment section below.


* As a side note, I have entire sketch books full of old game level designs from way back when. Maybe I’ll post some.

July 26 — Where I’m At

Well, here we are so far. A lot of work has been completed since the last progress report.

  • Voice recording and mastering is all done. That’s right. Every single line has been edited and made to sound like it’s coming over radio, so it’s all campaign-ready. I really enjoyed working with the individuals who were nice enough to offer their voice acting talents. (Finding enough actors was something I was initially concerned about, but many people were very willing to spend a half hour or so working with me to bring my characters to life. I’m very grateful for that.) There were a lot of bloopers filled with jokes and curse words. It made the editing process (which took hours upon hours) very entertaining.
  • The first 3 campaign missions have been built. These are shorter missions intended to gradually introduce features and familiarize the player with the controls, and are thus fairly simple. The remaining missions will be longer, but will probably be built quicker as I develop momentum (and gain familiarity with my own game engine…funny how that works). I have to say, it is incredibly exciting to see the action and hear my characters come to life in the way I imagined.
  • Various game play improvements. The targeting system has been improved, the computer players are smarter, bugs are being squashed…the list goes on.

Currently, my priority is getting the campaign finished. Building the missions not only advances the game towards completion, but also reveals bugs in the engine and helps identify game play issues.

Here is a screenshot from the third mission, Incursion, where a simple assault goes awry and the player’s forces are ambushed by the Coalition.

The player provides support during a mission to destroy a series of enemy network satellites.

The player provides support during a mission to destroy a series of enemy satellites.

Until next time.


July 5 — Where I’m At

It’s only been a week since my last update, but there’s been a lot of good progress. I’ll keep this quick since there’s a few other things I’d like to tackle this evening. So, here we go:

  • Voice recording is nearly, nearly done. Unfortunately, I didn’t reach my goal of having all of the recording done by the end of the weekend. A lot was done this week, but I’m still looking for an actor for the last part (Admiral Banks). All of the other parts have been recorded, though, which means that I can go ahead and build the first eight missions.
  • Improved the cockpit. I decided that even my meager art skills couldn’t excuse the poor quality of the existing design. I spent a few days building and texturing a new cockpit model, which is shown below.


  • Improved the missile system. The new system requires players to be smarter about how they launch their missiles; launches that are made too close to a target or not facing the target enough will only result in wasted ordnance.
  • Addressed a number of outstanding bugs and gameplay issues. All minor things, but there’s nothing like a quick demonstration to a colleague to make you realize there’s a lot that needs fixing. (“oops, that shouldn’t happen”, “still gotta fix that”, “that’s boring so I’ve left it until later”, etc.)


June 28 — Where I’m At

Okay, this is a big update. A lot has been accomplished over the last while!

The campaign script has received the final go-ahead from my editor/military consultant. His feedback has resulted in cleaner dialogue with a militaristic feel, which is definitely what I’m going for. Voice recording is proceeding, although much slower than I would like due to the time this takes. I’ve begun mastering the parts that have been recorded. All of the dialogue takes place over radio and is filtered to sound like it.

In addition to the campaign, I wanted Gateway to offer options for customizing and playing your own space battles. This “instant action” game mode is now entirely complete, and marks a major milestone in Gateway‘s progress. Certain parameters are randomized to give a slightly different feel to each battle, but the most meaningful per-fleet parameters (size of fleet, types of spacecraft and gates present, pilot skill level, technology, etc.) are fully configurable. Up to five different fleets of any size can be present, meaning that space battles can be as epic or as personal as you’d like. (They’re also very useful for quickly testing various aspects of game play.)

Featured below are some screenshots from scenarios generated by the instant action engine.

An enemy fighter tries to make a desperate escape.

An enemy fighter tries to make a desperate escape.

Exploding wingmates rock your fighter as two fleets collide.

Explosions rock your fighter as two fleets collide.

Alien cruisers unleash a storm of high-powered ordnance.

Marauder cruisers unleash a storm of high-powered ordnance.

Friendly fighters rush to assist in the defense of New Earth.

Friendly fighters rush to assist in the defense of New Earth.

Currently, my to-do list mostly consists of things like “fix cruiser UV issue”, “fix laggy menu widgets”, “finish new marauder fighter gate”, etc. There are also a few minor game features here and there that need to be implemented. Of course, there’s still the campaign to finish, but I don’t want to proceed until I have all of the voices ready to go. I hope to have them all recorded by the end of next weekend.

There’s still lots to do, but it’s as fun as it always is! And that’s the point.


Tech Report — Efficient Laser Bolt Collision Checks

I’m going to depart from my usual style of blog post and exercise my right to describe some technical stuff. This week’s topic is going to be about collision detection. It’s a massive topic, but for the purposes of today’s post, I’m going to focus on a very specific portion of Gateway’s collision detection system: how it handles laser bolts colliding with other objects.

Collision detection is potentially very costly, and the amount of collision checks between objects doesn’t scale linearly. The real trick is to discard potential collisions with as many objects as quickly as possible. In my attempts to reduce how often these checks had to take place in Gateway, I focused my efforts upon the most prevalent collision-enabled objects in the game world: the laser bolts.

In my game, lasers move very fast. We can’t rely on simple distance checks to determine if a bolt hits a fighter; the ordnance may very well simply ‘jump’ over the fighter and miss it entirely.

Simple distance checks will not suffice because the bolt moves so fast that it may skip over a potential victim

Simple distance checks will not suffice because the bolt moves so fast that it may skip over a potential victim, missing it

So, instead, we cast a ray between the old and new positions of the laser bolt.

As the laser bolt moves forward, our collision system performs a ray cast between its old position and its new one to see if it hit anything in between

As the laser bolt moves forward, our collision system performs a ray cast between its old position and its new one to see if it hit anything in between

This works fine, but we’re unnecessarily testing the ray cast against objects that fall behind the bolt. So, we discard any objects from the ray cast test that aren’t in its path. This can be done with a fast vector dot-product calculation and discards half of the objects we have to test against, on average.

Ray casting is expensive, so we should only test the objects that fall in front of the laser bolt's path

Ray casting is expensive, so we should only test the objects that fall in front of the laser bolt’s path

But, we can still do better than this.

Now, we’re performing these collision checks every frame. Even though we’re discarding a good chunk of the objects in our scene fairly quickly, that can still be costly in terms of pure iteration. These checks for discarding objects also consume resources.

Let’s think about this: laser bolts move really fast. Over the life of a single bolt (about one second or two), no ship is likely to change it’s position much. In other words, the set of potential colliders for any single laser bolt is fairly static throughout its entire life. So, why not just pre-compute a list of potential colliders at the beginning of the bolt’s life? This is likely to be a very short (or empty) list, and we can re-use it for every frame of the bolt’s life until it dies. In other words, we’re only computing the list of possible collision candidates once.

This page has some great code for a fast check to see if a point lies within a cylinder in 3D space. By specifying a radius wide enough to account for the fact that certain ships may cross the path of the laser bolt, we can use this to build a list of potential colliders that will remain valid until the laser dies. This list might only ever contain just a handful of ships out of hundreds, and will save our collision engine from tons of unnecessary iteration.

When a laser bolt is first spawned, compute a small list of candidates which we may collide against, and re-use it continually throughout the laser's life

When a laser bolt is first spawned, compute a small list of candidates which we may collide against, and re-use it continually throughout the laser’s life

In the image above, we can see that only two ships are within this cylinder. For that particular laser bolt, those are the only objects we have to check for collisions against. Pretty neat.

Of course, we’ve made a number of assumptions. We assume that the laser bolt is fairly short-lived and travels very fast. Slower or long-lived ordnance would necessitate the use of a wider cylinder, if we could still use this technique at all. Additionally, weapons that don’t move in a straight line (such as heat-seeking missiles) would present a problem. But for standard laser bolts, this works just fine.


May 18 — Where I’m At

Voice recording has begun! This is a very exciting step, as the voices for the characters I’ve imagined can finally come alive.

Now, the script is still awaiting some final editing from another source, so there may be the possibility of having to do re-takes to accommodate the changes. The reason I’m starting voice recording already is because I’m getting eager to move this game along!

Since the story is now more or less finished (barring some final editing), a lot of final decisions regarding Gateway‘s gameplay have been made. The campaign itself spans 11 complete missions, and there will also be the option of playing customized instant action games. During these missions, the player will face off against several types of one-manned fighters, a few varieties of cruisers, and even newly-added space mines.

There have also been a number of performance optimizations. Space battles can now be larger, and I feel that this is important when it comes to making the player feel immersed.

Don’t let all this talk bore you! Here are some screenshots to show you what to expect after a few more months of development.


Three outmaneuvered alien vessels face destruction from opposing sides.


The volcanic planet Grappley is visible behind the chaos.

The next while will be spent fine-tuning the game mechanics, eliminating obvious bugs, and integrating voices into the missions.