Posted on Leave a comment

Blog: Open-world RPGs and the Hinterlands problem

The following blog post, unless otherwise noted, was written by a member of Gamasutra’s community.
The thoughts and opinions expressed are those of the writer and not Gamasutra or its parent company.

This article contains minor spoilers for the first act of Divinity: Original Sin 2, including location and quest names.

As the market for modern role-playing games grows, developers are under increasing pressure to appeal to as many niches as possible. This is a problem endemic to mainstream game development – AAA development in particular – but Western RPGs are arguably the hardest hit by this. In this genre, attempting to accommodate every type of player results in a vast diversity of viable approaches to quests, story, and combat, but can give rise to disparate elements of the game and its narrative clashing with each other, resulting in a final product that feels vague, unfocused, and unguided. This pushes players into feeling bored or frustrated, which can quickly translate into disengagement and unfulfillment.

It’s In The Name

In Dragon Age: Inquisition, released 2014, a zone called the Hinterlands perfectly embodies this problem. It’s the first open-world area players visit, and it’s gigantic: larger than the entire playable areas of the first two Dragon Age games combined, according to the developers. It’s also densely packed with non-player characters, enemies, and quest content. In total, it contains more than fifty sidequests, which is a dizzying amount of content by any standard. This should be laudable, but in practice it’s a gigantic (and avoidable) misstep. When players were exposed to the zone, they got trapped in endless checklists and meaningless, irrelevant busywork that actively hindered story progression. Where BioWare tripped up in this situation was their failure to provide and, most importantly, maintain narrative and systemic motivation for players to continue out of the Hinterlands. There are a number of potential solutions to this: having sidequests require travel to other zones, for example, or designing some sort of in-game narrative event temporarily pushing players out of the Hinterlands to a scripted story segment (again, in another zone). A fundamental part of the Hinterlands Problem is that any momentum the story had before players entered the zone quickly dissipated. Something along the lines of these solutions would leave the Hinterlands and its fifty-four sidequests largely intact, but push players back into progressing through the game’s narrative.

Of course, Inquisition was hardly the first, or last, role-playing game to suffer from this – it’s just a highly visible example. Overly large amounts of quests and sidequests have historically been a selling point for RPGs, especially in BioWare’s earlier titles. However, that doesn’t necessarily mean that a large number of quests, or amount of narrative content in general, is the problem. The Hinterlands Problem is a complex beast, but a large contributor to it is the overall design itself being just a bit too shy to lend players a gentle nudge (or a firm shove) towards progressing through the game, narratively and systemically. It’s easy to understate the difficulty of doing this well: game designers constantly walk a tightrope, balancing the need to allow the player the illusion of organically advancing through the game with the need to make sure they’re actually advancing through the game and not wasting time rescuing lost cows. The solution isn’t just in removing the meaningless busywork or putting less context in: it’s a problem that has to be attacked from multiple angles, and it can require a multidisciplinary set of skills to fix.

Writing Narrative Cheques Your UI Can’t Cash

Divinity: Original Sin 2, an open-world RPG released this year, also suffers from the Hinterlands Problem. When the story and gameplay are heavily scripted (the narrative bottlenecks, so to speak) the game is lush, exciting, and does a splendid job of allowing the player to devise creative solutions to the narrative and combat-based puzzles that it provides. However, when the player is released into open maps such as Fort Joy and Reaper’s Coast, the narrative thread very quickly unspools into a tangle of half-finished quests and hinted-at storylines. Unlike in Dragon Age, though, most of these quests aren’t meaningless busywork. With few exceptions, they’re interesting, quirky, and humorous. Where many sidequests in Original Sin 2 do fail is in maintaining the game’s narrative cohesion, and this is a problem with potential solutions in tweaks of both its narrative design and its user interface.

When we look at Original Sin 2, we see a flawed gem: a sequel that had to live up to a hugely well-received predecessor, while introducing new mechanics and ambitiously pushing the envelope of how game systems and narrative interact. The downfall of the game is in its ambition: while the line-to-line quality, and the quests themselves (viewed individually) are stellar, the narrative cohesion falls apart when the player finds themselves pursuing any more than a few of the dozens of elaborate, impressive sidequests. It’s not a given that the average player can keep track of all these narrative threads, and a major contributor to Original Sin 2’s lack of guidance and cohesion is the game’s quest log (or Journal, as it’s referred to ingame). In a title that executes well on almost everything it tries, the Journal stands out as a piece of the user experience that disincentivizes its own use and largely fails to guide the player through the narrative as a whole. Progression-related quests are given no special markers, and there’s no way to “bookmark” a quest, so players must constantly bounce back in and out of the menu system to keep track of what they’re meant to be doing. Not only does this break the game flow, it contributes to the failure of the Journal at the one thing it’s there for: guiding the player through the process of completing quests. Divinity: Original Sin 2’s version of the Hinterlands Problem is one where an overabundance of narrative threads and an undercooked UI element crash into each other to cause a muddled, unfocused open world experience, and the game is the lesser for it.

Snip Your Threads Judiciously

The Hinterlands Problem can be summed up as being a situation where too much optional content and a failure to provide a clear forward path for the player causes frustration, boredom, and a decrease in narrative cohesion. No game designer designs systems with these outcomes in mind: rather, the Hinterlands Problem is a common and natural byproduct of good-intentioned, if myopic, design. It’s the result of a failure to keep the bigger picture in mind, and, again, nobody does this on purpose. It just happens. To mitigate the chances of this happening, narrative designers and game designers must continually interrogate the means through which players will consume and advance through content; they must have open dialogue with systems and UI designers; and above all, they must play through and review each other’s content. Too much work in studios of all sizes takes place in isolation, and that status quo is the perfect breeding ground for problems like this.


Damon Reece is a narrative designer from Adelaide, Australia, passionate about open-world and modular storytelling. Damon prefers gender-neutral pronouns (they/them), and hates talking about themself in the third person. You can follow them on Twitter, or look at their portfolio if you’re having trouble figuring out whether to take them seriously.

Posted on Leave a comment

Virtual reality outfit Bigscreen raises $11M to expand social app

Virtual reality studio Bigscreen has secured $11 million in Series A financing to make new hires and accelerate the development of its social platform. 

The round was led by venture capital outfit True Venture, and takes the company’s total funding for the year to $14 million. 

For those unfamiliar with the company, Bigscreen is the developer behind the aptly named Bigscreen social virtual desktop app for Vive and Oculus Rift. 

The free app (currently in beta) lets users hang out in virtual theatres and other digital spaces where they can do things like play games, work, and watch movies together. Bigscreen hopes the latest cash injection will help it cope with the app’s rapid expansion. 

“Over the past year, Bigscreen has grown significantly to more than a quarter million users. In just the past few months our core metrics grew over 300 percent,” reads the Bigscreen blog.

“Our power users spend 20 to 30 hours using Bigscreen every week, and many users have spent more than 1,000 hours in Bigscreen.

“Based on usage and user reviews, Bigscreen is now one of the most popular VR apps in the world. We now need to grow the team in order to improve the product and expand the Bigscreen platform to more VR and AR devices.”

Posted on Leave a comment

New Developer Interview: Get the inside story behind the making of Kirby Super Star

New Developer Interview: Get the inside story behind the making of Kirby Super Star

He’s pink. He’s cute. He’s Kirby! Learn all about this puffed-up hero an in-depth interview with his creator, Masahiro Sakurai, and find out how they brought two player co-op gaming to the Kirby series in the Kirby Super Star™ game.

To play Kirby Super Star and many more classic titles, check out the Super NES Classic Edition system, now available for a suggested retail price of just $79.99. This miniaturized version of the original system lets you plug-and-play 21 classic Super NES™ games.

Learn more on the official site at

ESRB for Super NES Classic Edition:

Mild Blood
Suggestive Themes

Posted on Leave a comment

Midweek Madness – The Surge, 50% Off

Save 50% on The Surge during this week’s Midweek Madness*!

Defy deadly enemies and huge bosses in tight, visceral melee combat. Target and slice specific limbs off your foes, with a next-gen loot system where you loot what you dismember. Equip, upgrade and craft new weapons and armors sliced from enemies, and make yourself stronger through a fresh take on leveling-up.

*Offer ends Friday at 10AM Pacific Time

Posted on Leave a comment

How GladOS solved one of Portal’s biggest problems

The Orange Box is a decade old, but it only seems like yesterday that Valve’s five-game compilation, which included Half-Life 2 and its two continuations, Episode One and Episode Two; Team Fortress 2; and Portal, was hitting shelves

It’s strange to think that, back then, Portal was something of a mystery. Half-Life was still going strong (those were the days) and Team Fortress had already amassed a following, but no one had any idea what to expect from the quirky, reality-bending puzzler. Not even Valve. 

Despite being an unknown quaniity, Portal soon became the talk of the town. And while the portal-flinging mechanics were truly special, it was the game’s robot antagonist, GladOS, that emerged as the star of the show. 

Now, in a recent interview with PC Gamer, Valve designer Robin Walker has explained how the cake-loving maniacal machine came to be. 

“In any game’s development, there are too many decisions to count, and many of them will ruin the game if made incorrectly,” says Walker. “One decision that ended up being very important was the one behind GladOS.”

Walker recalls how after a year in development, the team had 14 levels ready for playtesting. There was, however, no GladOS, and players moved from puzzle to puzzle without any real sense of narrative progression or reward. 

Playtesters still responded positively to that GladOS-free experience, but many kept asking “when does the game start?” Without any story beats to hit or emotional adversity to overcome, most felt the core levels were tutorial missions leading to something bigger. That’s when Valve became worried. 

“Considering the entire game was really just a process of learning about the core gameplay mechanic, this scared us a lot,” continues Walker. “We talked about various solutions, and in the end decided that introducing an antagonist made the most sense.

“The antagonist could start as a narrative tool for introduction and reward, and over time become the thing that pushed back on the player, eventually giving them the core goal of the game. We had little in the way of art production on the team, so it being a character that largely spoke to you via voice over was a straightforward production solution.

“In the end, there are many important decisions after this that were critical to GladOS working as well as she did, such as her entire personality. But her genesis begins with a straightforward process of us trying to solve the core gameplay problem in Portal.”

The full interview goes into more detail and is well worth a read. Check it out over on PC Gamer.

Posted on Leave a comment

Hellblade dev marking World Mental Health Day by donating game sales to charity

Hellblade: Senua’s Sacrifice developer Ninja Theory is marking World Mental Health Day by donating all proceeds from today’s sales of the game to mental health charity, Rethink. 

Rethink is a UK organization that supports and campaigns for those severely affected by mental illness. The group wants to help those affected by the invisible illness by challenging and changing attitudes.

Hellblade’s protagonist Senua, suffers from psychosis, and both critics and fans have praised the way the game delicately and intelligently represents the condition. 

Ninja Theory has put together a new game trailer for the occassion, but instead of featuring buzzwords and marketing jargon, this one spotlights messages sent in by Hellblade players keen to share their own mental health experiences. 

Donations will only be taken (after sales tax and platform fees) from PS4 and PC purchases made on October 10, so if you’ve been waiting for a good opportunity to dive into Hellblade, now’s the time.

Posted on Leave a comment

Blog: Bringing Galaxy on Fire to Vulkan – Part 3

The following blog post, unless otherwise noted, was written by a member of Gamasutra’s community.
The thoughts and opinions expressed are those of the writer and not Gamasutra or its parent company.

Written by Max Röhrbein-Kling and Johannes Kuhlmann

This is part three of our series of blog posts on our experience with bringing Galaxy on Fire 3 – Manticore to Vulkan.

Our posts follow this structure:

  1. Introduction and Fundamentals
  2. Handling Resources and Assets
  3. What We Have Learned (this post)
  4. Vulkan on Android
  5. Stats & Summary

Before we dive into the matter, we would like to point out once more that the focus of our Vulkan renderer was to ship a game. Thus, it is more pragmatic than perfect and we have mainly done what has worked for us – so there is no guarantee that our best practices will also work for you. We do believe, however, that our implementation is still reasonably versatile and well done. And we hope that you can learn a thing or two from our approach.

This third post covers a bunch of little problems we encountered while implementing Vulkan support and getting it to work on different devices.

You Have to Pay Respect

One of the things we learned when bringing our Vulkan renderer to different devices and GPUs was that it is very important to pay respect to the targeted devices’ limits, properties, and capabilities. With Vulkan, almost anything can be queried. Most things you have to query before you go ahead and do it. Some things we knew about, some came as a surprise. To shed more light on this issue, we are now going to discuss a few examples that struck us as the most important ones.

One such example is maxMemoryAllocationCount of a Vulkan device. This number tells you how many VkDeviceMemoryallocations can be live at the same time. Per spec, the minimum is 4,096. As it turns out, there are numerous devices out there that have a maximum of 4,096 (Adreno GPUs, for example) – a number we are apparently able to exceed with all the vertex/index buffers, uniform buffers, textures, and so on. So, as most Vulkan tutorials recommend, you should think about memory management early on and not make one allocation per buffer.

We also had problems with the alignment of our data. There is the device’s minMemoryMapAlignment and then there is the alignment you get from vkGetBufferMemoryRequirements(). In some cases, we had to take the maximum of the two in order to get the correct alignment.

You will also want to check the API version of the device you have. Make sure it is actually the one you programmed against. We had some Vulkan implementations where the major version was 0 and things like the VK_KHR_swapchain extension or validation layers were not available at all.

A Vulkan implementation must support one of the following texture compression methods: ASTC, BC, or ETC2. If you want to be compatible with all Vulkan devices, you better support all three texture compression formats. However, on Android, we have gotten away with only supporting ETC2 so far. This is due to the fact that all devices we target support it (presumably due to it being required by OpenGL ES 3).

The framebuffer formats also vary from device to device (be it RGBA or BGRA, or whatever). And depth and stencil formats are wildly different between GPUs, too. They can also be combined or not, for example.

Additionally, there are some other small things like the alpha compositing mode (VkDisplayPlaneAlphaFlagBitsKHR) or the surface transform (VkSurfaceTransformFlagBitsKHR) for which different values are supported by different devices.

Validity Does not Imply Correctness

If you have worked with Vulkan, you have hopefully also used its validation layers. These layers basically stand in-between your game/application and the Vulkan driver, making sure your usage is valid. The layer concept is not exclusive to validation, but it is normally the first use case you come in touch with. There are different validation layers that focus on different areas where problems might occur. For example, there are layers for parameter validation, API state, and correct threading. The validation layers are Open Source and can be found on GitHub.

The beauty of the layer concept is you can enable error checking and validation when you need it and disable it to have zero overhead when you do not need it. We would like to emphasize that you really should use the validation layers whenever something is wrong. Make them super-easy to enable (without rebuilding) and maybe even run with them enabled by default if performance permits.

The validation layers are still constant subject to change. Even which individual layers there are and what layer does what is not set in stone yet. Therefore, you should get them from GitHub and build them yourself if you want the latest checks.

You should load the validation layers in order. Contrary to what we had assumed in the beginning, the validation results may be influenced by the order you specify the layers to be loaded in. There is a recommended order which can be found here and here.

The validation layers are specific to the device you are running on. Of course, their code is the same for all devices, but the layers ask the given Vulkan device for its limits and capabilities. The layers do their validation based on that information. So, just because you do not have any validation issues on one device, it does not mean you will not have any issues on other Vulkan devices.

One very Android-specific issue we faced was that at some point our validation layers were not found by the Vulkan driver anymore. It just kept looking in the wrong folders. This happened after we integrated the Google Play services into our game. The same engine was able to find and load the layers successfully in a rather empty project without anything from Google Play in it. This bug seems to be specific to ARM Mali GPUs. We have reported the problem and hopefully it is going to be fixed at some point.

It is Easy to Lose Your Device

One thing that eventually will happen with Vulkan is that you do something wrong. On Android, you will then most likely get the dreaded VK_ERROR_DEVICE_LOST result which means your driver or GPU had to be restarted. Your Vulkan device will probably not recover after this without a restart of the game. It may continue rendering, albeit with worse performance as the error keeps occurring.

This problem is very difficult to debug because everything is asynchronous. Via the Vulkan API you submit commands to the driver. While these commands may already be processed asynchronously, they will most likely also be executed asynchronously on the GPU. The result from the execution will then again be sent back to the driver asynchronously. If there is an error in this procedure, your Vulkan code will only detect it when it tries to call one of the Vulkan functions that may return the error. So, it is rather difficult to pinpoint the one Vulkan call causing the problem.

If you get VK_ERROR_DEVICE_LOST, it is best to simplify what you are rendering until the problem does not occur anymore. From there, you might be able to debug whatever problem you have with one specific asset or its render setup.

For us, causes of a lost device included:

  • reading and computing things with garbage uniform data
  • sampling textures to whom nothing was ever assigned to
  • synchronization issues, i.e. reusing or destroying resources while they were still used elsewhere

Of course, there were certainly other causes as well. But the ones listed above struck us as the most prominent.

Drivers Have Issues, too

Normally, when something goes wrong, we first suspect it to be our fault – a notion that very often turns out to be true. However, this changed a bit when we were working with Vulkan on Android. At various points, we had to accept that it might not have been our fault and that there might simply be problems we could not fix at all.

In addition to the validation layer problem in one of the previous sections, there were two cases where we concluded that the driver must be at fault. Both happened on Qualcomm Adreno GPUs. Of course, to say it again, there is still a chance that these problems were caused by something we did. But in both cases, we could work around the symptoms by avoiding the addressed features.

In the first case, our uniform structs were assigned to the wrong uniforms in the shader. So, basically our rendered objects behaved very weirdly as their uniforms did not have any sensible values. We tracked this problem down to our DescriptorSets somehow being wrong. We made sure our binding numbers were correct in VkDescriptorSetLayoutBinding. And everything seemed fine, but our uniforms were still just as wrong as before. As it turned out, the driver was not using the binding numbers to bind the uniform structs, but instead their index in the array of VkDescriptorSetLayoutBindings inside VkDescriptorSetLayoutCreateInfo. A simple sort by binding index fixed that problem after days of debugging.

Another problem manifested itself with lots of flickering of one or multiple objects. The flickering intensified when pulling down the Android menu from the top of the screen. This problem was apparently somehow caused by our usage of dynamic pipeline states. Specifically, we had the viewport and scissor rect marked as being dynamic which results in them not being part of the graphics pipeline state. Disabling these features made the flickering go away. Luckily, we did not really make use of the ability to change around the viewport or scissor rect a lot.

In addition to things simply being broken, we also had problems with various GPUs behaving drastically different from each other. These were problems where we were wrong according to the Vulkan specification, but everything was still working correctly on a lot of devices. On others, however, this was not the case.

For example, we could map a memory buffer twice (using vkMapMemory()) even though that should not be possible. Or we forgot to specify external dependencies for our subpasses (VkRenderPassCreateInfo), but everything still rendered fine on all devices. At least most of the time. On some devices we encountered some objects to be missing occasionally for one frame at a time. Another example is that we specified a depth of 0 in VkImageCreateInfo for our 2D textures and it still worked on quite a few devices. The correct value should have been 1, obviously.


There are lots of little – or not so little – things that can go wrong in a Vulkan application. Luckily, the validation layers report most of these issues.

And then there are issues where you spend ages looking for the problem, have checked the Vulkan standard a dozen times, but everything looks correct to you. In such cases, it might help to assume your driver may not be implementing the standard correctly and see if that reveals a workaround to you.

In the next post, we will talk about some of the challenges we faced when bringing the Vulkan renderer to Android.

Posted on Leave a comment

Go on a beauty adventure with shu uemura x Super Mario Bros.

Go on a beauty adventure with shu uemura x Super Mario Bros.

Score major style points with this collection of beauty products from shu uemura. Each item features special packaging inspired by the Mario Bros. franchise-especially the super cute Princess Peach. In addition to limited-edition eyeliners, blushes, and other makeup, the collection features a cool way to organize it all with the Adventure Makeup Box.

Level up your look (or pick up a gift for your favorite gamers) on the shu uemura site.

Posted on Leave a comment

Classic Postmortem: XCOM: Enemy Unknown, which turns 5 today

In honor of the 5th anniversary of the release of the brilliant XCOM: Enemy Unkown, we present this classic postmortem, which first appeared in the January 2013 issue of Game Developer magazine.

The game was a “reimagining” by Firaxis of the classic 1994 strategy title UFO: Enemy Unkown, as well as a reboot of the XCOM series. It was a smashing success, earning numerous awards and GOTY accolades.

This in-depth look at what went right and what went wrong during development was written by Garth DeAngelis, who was the lead producer and a level designer on XCOM: Enemy Unknown.

There may have been wounds, but somehow, the XCOM: Enemy Unknown development team evaded permanent death.

In 1994, Microprose released a special PC game called UFO: Enemy Unknown. The turn-based strategy title accumulated a devoted fanbase for its unique take on high-level management against an alien invasion blended with boots-on-the-ground, intimate combat controlling individual soldiers. Fast-forward almost two decades, and Firaxis Games has released XCOM: Enemy Unknown, a reimagining of Julian Gollop’s original design.

The road to completing XCOM was an arduous one. We made many of the same mistakes that other devs have made (and documented in previous Game Developer postmortems): feature creep, communication shortfalls, not enough time, not enough people… If you’re a game developer, you know the story. But through it all, the entire team remained resolute, and in October 2012, against all odds, the development team managed to save Earth ship XCOM on PC, Xbox 360, and PlayStation 3.

Lead designer Jake Solomon planted a small seed within the creative walls of Firaxis Games in 2004. As the self-proclaimed “biggest fan of the original X-COM” and as a designer/programmer working directly with Sid Meier, it made sense to spark discussion regarding resuscitating one of the greatest strategy titles of all time. After shipping Civilization Revolution, the stars began to align, and the rebuilding of XCOM became a reality.

Before any code was written or any art completed, Jake defined core pillars that would act as the foundation for pillars that would act as the foundation for designing the rest of the game. All facets of game development had clearly evolved since 1994, from game and narrative design to user interface, but Jake remained adamant that certain high-level elements from the original remain holy. These inspirations included maintaining a turn-based combat system, which seemed risky in the modern age of frenetic first-person shooters and real-time action games.

The game would also preserve the symbiotic relationship between the micro combat layer and a macro, grand strategic mode, where the player runs and builds their own secret headquarters to counter the simulated alien invasion. Fans of the original game understood the appeal of these interdependent systems, but to those unfamiliar with the XCOM franchise, this was a foreign game structure, and that equaled potential big risk.

Other smaller pillars included: updating systems such as the fog of war and how visibility would be communicated to the player in a 3D environment; fully destructible environments, a satisfying staple from UFO: Enemy Unknown, but a potential challenge in a game of this scope; reintroducing players to permanent death, and the fact that when it comes to XCOM soldiers, there are no such things as extra lives; and recreating the tense atmosphere from the original.

It was critical to place the player in a world they recognized—in settings they may recall from their own neighborhood or city—and then introduce a menagerie of new and classic aliens into these usually safe environments. This led to an unnerving despair that XCOM fans are all too familiar with. Collectively, these pillars provided the foundation for a challenging experience that presented true consequences, just like UFO: Enemy Unknown.

Firaxis underwent a pitch process that previously had not been attempted with past projects, but then again, we were pitching what was essentially a new IP as a big-budget endeavor, so we needed to make a major splash.

Getting the green light to remake an antiquated turn-based strategy game would be a challenge, and simply verbalizing what made XCOM so special and ripe for a rebirth wouldn’t be enough. The team needed something that would make everyone understand why we were so passionate about undertaking this project—something beyond a static presentation.

Jake began working with project art director Greg Foertsch and a small band of artists to create a gameplay previsualization. Over the course of multiple months, Greg and his team ate, breathed, and slept UFO: Enemy Unknown, ultimately planning a storyboarded sequence that would illustrate how Firaxis’s take on the XCOM universe would not only look, but also how it would play.

On Fridays, Jake would sit in a room with the team while they immersed themselves in the original game, becoming familiar with its nuances and big concepts alike. This collaboration led to a compelling previsualization that not only got the development team on the same page, but also communicated to nondevelopers the potential for a classic turn-based experience to be reborn as something cutting edge, distinctive, and thrilling in the modern age of video games.

Even before beginning work on XCOM , we heard it all before: Games had become too easy. The development (or marketing) buzzword “accessible” translated to “dumbing down,” the idea that developers would take an otherwise deep, rich, and satisfying game and distill its intricacies to its barest form so the entirety of the world could understand, buy, and play said game.

It sounds hyperbolic, but I’ve seen games with easy modes that literally played themselves, making failure impossible, so this stigma against accessibility wasn’t without merit! Making a game “for the masses” could be the ultimate transgression, especially for a complex game with a hardcore past, and we anticipated that XCOM fans would be skeptical that our work would hold up to those who fell in love with the original.

While UFO: Enemy Unknown may have been magnificent, it was also a unique beast when it came to beginning a new game. We often joked that the diehards who mastered the game independently belonged in an elite club, because by today’s standards the learning curve was like climbing Mt. Everest.

As soon as you fire up the original, you’re placed in a Geoscape with the Earth silently looming, and various options to explore within your base—including reading (unexplained) financial reports, approving manufacturing requests (without any context as to what those would mean later on), and examining a blueprint (which hinted at the possibility for base expansion), for example—the player is given no direction.

Even going on your first combat mission can be a bit of a mystery (and when you do first step off the Skyranger, the game will kill off a few of your soldiers before you even see your first alien—welcome to XCOM!). While many fans on the team found this learning curve to be a part of the game’s charm and wore it as a badge of honor, we ultimately knew that, in 2012, we needed to enable gamers to experience the truly fun elements without overly testing their patience. But neither could we bear to dumb XCOM down.

We were on a mission to flip the perception on streamlining, to remove the stigma that accessibility equaled a dirty word. We wanted anyone to be able to give XCOM a whirl without expecting them to become fluent in the game’s many systems on their own accord. At the same time, we needed to preserve all of the richness, depth, and challenge ingrained in the core pillars. If someone wanted to walk away from the experience due to the game’s challenge, we were okay with that; but we didn’t want to alienate anyone simply due to a lack of information.

To accomplish this, we built an optional, integrated tutorial that peeled off the components of XCOM one layer at a time. It was important to keep this hour-and-a-half experience optional, as experienced players could save Earth again without the tutorial force-fed to them (and we also knew some players, even in 2012, would want that old-school badge of honor by skipping the tutorial altogether, which is somewhat appropriate for certain types of X-COM fans).

The introduction to the game wasn’t the only area we redesigned. Jake and the design team refined low-level mechanics from the original, such as removing Time Units and capping the squad loadout at six. Both of these changes were the result of internal playtesting over the course of many months, with the development team finding a combat “sweet spot” with respect to approximate time spent on a map and number of decisions made per turn (we found, depending on map size, battles should average 20 minutes, not to exceed 50 minutes on the absolute longest missions). Six units also made every decision vitally important, promoting group tactics with no moves feeling like unnecessary filler.

This “new era of accessible” mindset also helped the design and user interface teams build a platform-agnostic experience. This is an element that could have gone horribly wrong (and did have its inherent challenges, detailed later), but the team did an admirable job of crafting a historically PC experience for consoles as well. We knew games like XCOM weren’t traditionally available on Xbox 360 and PlayStation 3, but we’re extremely happy we could provide the same experience (without compromising features or “dumbing down” the console versions) across all platforms.

The developers at Firaxis are extremely professional, with each discipline playing the hero role at some point and overcoming monumental obstacles throughout development. From the audio group to the animation and narrative team, they were continually course-adjusting due to dependencies, yet still producing incredible content to polish the game.

On the engineering front, months of changing design had to be technically supported in many complex situations. Systems were built, iterated upon, and some were even discarded after determining a new direction was needed. For example, over the course of a few milestones in midproduction, design asked for sightlines to be drawn from every game unit, soldier, and alien alike, so it was clear what each unit could see.

Our graphics engineering team and artists diligently worked to make this system digestible, but unfortunately, it was tough for the player to determine what was going on amidst the plethora of multicolored lines. After months of trying to get sightlines to work, we eventually realized that the strongest solution was to remove them.

There were plenty of other challenging systems to decipher: the building visibility system underwent various ceiling, wall, and floor rule changes; destruction fidelity fluctuated through a shaky toughness system; and the fog of war was a full 3D cloud early in production, which proved to be a nightmare for both graphics engineering and performance.

Additionally, each gameplay layer (combat and strategy) received drastic overhauls after months of playtesting. In all of these cases, initial engineering efforts had to ultimately be thrown out. To the team’s credit, they understood the nature of iterative design and admirably continued to put in the time needed to make the game a better experience.

In addition, the engineers banded together in a Herculean effort to fix thousands of bugs in postproduction. XCOM is a large, system-driven game with many procedural elements. This meant that many bugs were not only difficult to reproduce, but challenging to even find! Together, engineering raised the bar of the final player experience by squashing these bugs feverishly. Obviously, we couldn’t find and fix every bug, but we’re proud of the effort given in the race to the finish line.

The art and content teams also worked minor miracles. A primary example was the game’s levels. We all love maps and levels, and want more of them; but they are a nexus of many different disciplines somehow crafting the same sculpture all together, and this requires tight coordination and lots of time. Firaxis had never created a level-driven game before (with a strategy system still on top of it, no less), so we had to learn how to build a pipeline that would let us efficiently design and build level assets.

This specifically required an inordinate amount of collaboration between level design and level art, weeks of gameplay testing and feedback per map, and an extreme amount of content creation (we needed to have approximately enough maps for two full playthroughs). In the end, our modestly sized level team ended up exceeding the original goal of 70 unique maps.

Beyond levels, there was still an entire headquarters to build on the strategy layer, with dozens of expandable rooms that could be hand-placed by the player. After making various isometric prototypes, we realized the base wasn’t nearly as gripping as we’d like; something was missing.

Lead technical and HQ artist Dave Black pitched the “ant farm,” a diorama-style side view that instantly connected with the entire team. This was an entirely new process as well, but Dave and the art team concurrently exceeded expectations on headquarters while finalizing all of the combat maps.

We’ve heard countless horror stories about publisher-developer relations, with publishers stifling creativity, dictating direction, or creating impossible deadlines—but our partnership with 2K Games was not one of those horror stories. While there was give-and-take from both sides (as in any relationship), we were overwhelmingly happy with 2K Games’s support—especially considering no major publishers have funded a large-scale, multiplatform, turn-based strategy game in recent memory.

2K believed in our vision and greenlit the project, something we’re not so sure would have happened elsewhere. The 2K Product Development group believed in the potential for a reimagined XCOM and also understood that taking risk was necessary. We were ecstatic to learn we would be given this opportunity.

Furthermore, 2K trusted in us as a studio to own the creative direction of the title. While they provided in-depth milestone feedback, every item was up for discussion, and they ultimately trusted in our design vision. 2K also provided us with additional resources to build an integrated tutorial, something that became critical late and ballooned beyond our initial resource estimations. This type of support proved invaluable to finish the game.

Also, 2K’s public relations team was instrumental in raising the awareness for XCOM. They took the time to understand the vision and value of the project, and allowed the team leads to directly and candidly communicate that vision to the player base. PR worked diligently to uncover many valuable opportunities for the game, including a cover reveal with Game Informer magazine and various demo presentations to targeted press.

These presentations planted the seed in our most passionate advocates—the press—to pass along what they liked (or disliked) about the game’s potential. There was also a strong working relationship between PR and the development team, leading to joint initiatives like the “Jake Solomon Undercover” video and exciting panel discussions like PAX’s “1000 Stupid Ideas on the Road to Glory.”

[embedded content]

XCOM required constant design iteration, with some features being implemented beyond Alpha. It may sound cliché, but Firaxis has always lived by the mantra “Find the Fun,” and the company takes that very seriously. Sometimes, fun can be a challenge to find, especially in a product that is unlike any other we’ve built before. XCOM boasts two interdependent systems that could almost be standalone games, and discovering that special synergy between the two was the key to unlocking the magic within the XCOM universe.

Trying to focus concurrently on both gameplay layers was challenging. We spent various milestones on certain features that didn’t progress as we’d hoped. By midproduction, the strategic layer was a turn-based card system for various months, and it stagnated while the team focused on improving combat. Ultimately, the strategy layer was molded into the version we’re satisfied with, but it was neglected for too long and required a late Half-Life-inspired Cabal process to get there.

We (myself, Solomon, and other members of the dev team as necessary) would meet every morning, every day, until each component of the strategy layer had a concrete game plan and a clear implementation schedule. Additionally, the tutorial and narrative, critical components of the game, couldn’t be pushed to final until the design was locked. And since the design tentpoles ran late, the narrative team (including animators, writers, and audio) came under immense pressure to finalize high-quality cinematics in an extremely short timeframe.

The extra design time helped make the game as good as it could possibly be from a gameplay perspective, but it’s worth asking whether we could have made tough calls on certain systems earlier in the schedule. This is one of game development’s largest challenges: Holding a game’s design to immovable deadlines can be stifling to the iterative and tricky-to-quantify creative process.

Shipping an unpolished combat game with a completely disconnected strategy layer would have spelled disaster for the future of XCOM, so we kept the process malleable much later into the schedule, allowing the team to find the answers through discovery and experimentation.

Practices like the design cabal helped the team focus on areas of the game that weren’t fun, but in a perfect world, we would have locked down as many high-risk systems as possible as preproduction wrapped up. We did ultimately cut content, but the bulk of our wishlist shipped in the final product, which was great for the game but taxing on the team.

By Alpha, only a few systems needed to be implemented, but a new challenge was looming around the corner: the bug database. Before Alpha, the team had a good sense of the state of the game and which systems were most playable, but it was difficult to quantify the true workload until QA began fully testing the game for a few weeks. The reported bug count rapidly multiplied like termites silently infesting the framework of an otherwise beautiful house.

Initially, we weren’t quite sure what to expect, but as the picture became clearer, we knew we were in for an inordinate effort to keep pace with the influx of bugs. There were concerns about the amount of work needed to fix the game relative to the engineers on the team. We had a ship date to hit and we wanted to get our dedicated engineers help.

But the mythical man-month is a very true concept. While our publisher was generous with additional resources to assist toward the end of production, we found that a flood of external helpers had undesired consequences. Knock-on bugs due to unfamiliarity with the codebase, content that needed to be fixed by internal artists, and communications inherent in outsourcing relationships all led to an extreme amount of overhead that ultimately fell onto the laps of internal team members who were already responsible for an aggressive workload.

Outsourcing challenges also hit the content-creation team during production. Communicating with an external cinematic team overseas led to a staggered communication channel. Since there were dozens of unanticipated clerical issues just to get their tools up to speed with ours (no fault of theirs), it was extremely challenging to troubleshoot any setbacks. Also, providing creative feedback to most external partners often led to significant delays due to the remote feedback loop and misinterpretations of feedback via email.

Once we were late into production, the leadership team wanted to maximize each developer’s working hours by being judicious regarding meeting requests, even amongst ourselves. Process-driven meetings were reduced along with costly, 20-plus-person large-scale meetings. We still maintained informal but intimate one-on-one reviews with each discipline’s lead, which was intended to be more focused and fruitful per developer. While the leadership team and some team members appreciated this, others were understandably yearning for additional official communication channels.

Also, team members wanted quicker information on the high-level changes to the design of the game, but with our lead designer doubling as a gameplay engineer, he would often be tied up with coding. Finally, cross-discipline groups (like level design and level art, and feature-specific teams) surely could have benefited from a more formalized stand-up process, which we implemented toward the end of production.

Moving forward, the leadership team knows it needs to strike an appropriate balance between optimal information flow and excessive meeting time, hedging toward more opportunities for formal communication.

Not only was the game structure of XCOM unlike anything the studio had built before, this was also the first time we’ve had to concurrently develop versions for three different platforms. It turned out managing all three was a massive amount of work.

Design-wise, the team knew there would be feature parity between PC and consoles; the only difference would be the control scheme. While the design and UI team did an admirable job on this front, there were continuous challenges throughout development to accommodate multiplatform user interface design, specifically tied to this genre. The team had to ensure all tactical commands were accessible via gamepad, and this involved quite a bit more than accommodating a point-and-shoot mechanic.

The movement system, mapping a system to support dozens of contextual abilities, and crafting a uniform Shot HUD were just a few areas that took time to master across the board. While this specific instance arguably didn’t go “wrong,” it is a small example of the multiplatform challenges faced daily.

The system-specific optimizations needed for each platform were significantly more difficult, particularly for the consoles. Understanding the console constraints for items like number of maps, audio files, texture budget, and animation sizes was a continual process between engineering and the specific disciplines. There were also severe, system-specific bugs, technical requirements, and crashes that ate up much of our senior engineers’ time.

Our systems engineering team was a very talented duo, but they didn’t have a dedicated platform engineer, which meant that they had to partner on all of these complex issues across the board. While they worked together effectively, they simply had too much work on their plates: universal systemic issues, art optimization requests, and other general and technical requirement bugs, just to name a few major workloads.

Our lead engineer assisted on the most difficult issues when he was free from putting out other fires, and another internal systems engineer joined the cause late in the project to own the Xbox 360 technical certification requirements, but these were solutions that emerged late in development.

We’re not proud about the fact that we had to crunch to finish XCOM. We have a dedicated and passionate team, and all team members put in serious extra hours at some point for the good of the project. For many, the malleable structure of the game led to frustration as we were knee-deep in the trenches. Certain dependencies were continually pushed (especially impacting audio, effects, cinematics, and user interface) and the lack of testing on late gameplay systems led to a heavy bug load for the engineers.

On the art side, the content creators had production crunches to finish all maps. As said before, this was the first time we created a game of this structure, and the first time we had to iterate so much on the process itself. While we improved certain inefficiencies throughout production, we simply couldn’t accurately predict how much time we’d need to make the game the way we wanted to make it.

In the end, we avoided permadeath. And after all of the extra hours, the thousands of bugs fixed, the hundreds of level playtests dissecting every piece of cover, the dozens (hundreds?) of gameplay prototypes and healthy debate that accompanied each new system, through every team meal, and in the wake of every hopeful or concerned hallway discussion, in the end, the XCOM development team emerged victorious.

We shipped the project within weeks of our original target release date, earned a near-90 Metacritic from video game journalists, garnered hundreds of game accolades, and won 13 Overall Game of the Year awards. Most importantly, a wildly creative and cross-discipline team banded together to contribute to the unlikely revitalization of a classic game, capturing the magic of X-COM for a new generation of gamers and hardcore fans of the original alike.