Eldritch Eldritch 2 Slayer Shock

Turtles (All the Way Down)

My procedural level generator has come a long way since Eldritch, and outside of the occasional forum post or summary tweet, I haven’t documented it in any meaningful way since 2015. I’ve made a lot of changes for game jams and abandoned projects between 2017 and 2023, and I’ve recently made even more changes as Eldritch 2 takes a clear shape in my mind. I’m sure there will be more changes along the way, but this is the current state of it.

Prologue: Goals

I’ve used versions of this procedural level generation system in two commercial titles (Eldritch and Slayer Shock) and three recent game jams (NEON STRUCT: Desperation Column, Li’l Taffer, and Schloss der Wölfe). These games each have different goals and different reasons to use proceduralism. Eldritch was a roguelike (or roguelite), and it used procedural levels in the conventional roguelike way, generating new dungeons after each player death. Slayer Shock was a longer campaign game where total failure was a rarer occurrence, so it used procedural levels to create the dozens of missions a player might attempt throughout that campaign. I only expect my game jams to be played once, but they used a mix of bespoke and procedural level design to offload some of the burden of making levels under limited development time constraints.

I have made just as many games and game jams that did not use procedural levels at all. I believe procgen is a tool to use when it supports a game’s design and production needs, and its development should be guided by those needs. When I was invited to speak at GDC about the level generation in Eldritch, I called my talk “Procedural Level Design” rather than “Procedural Level Generation” because every decision I made on that algorithm was a level design decision.

Chapter 1: Eldritch

I spoke about Eldritch‘s procedural levels in length at GDC, and you can watch me be uncomfortable at public speaking or you can make us both happier and just read the slides. Also, Eldritch‘s levels were heavily inspired by Spelunky‘s levels (just extruded into 3D), and I highly recommend reading Darius Kazemi’s excellent interactive guide to Spelunky‘s generator. But a quick summary:

Eldritch‘s generation began by generating a maze on a small 4x4x3 grid, where each grid cell represented a 12x12x8m block of space. After that maze was created, it would randomly open some additional paths to create loops in the maze. Then it would turn that into a real space by populating each cell in that grid with a “room”: an authored 12x12x8m chunk of level design, consisting of voxels and entity spawners. Each room was built to fit a certain configuration of maze directions (north, south, east, west, up, and down), and during generation, a room would be selected at random from any of the authored rooms that could fit a maze cell.

In order to minimize the amount of rooms I had to create and to maximize the apparent variation, each room could be used in any of 8 transformations: its default, or rotated by 90, 180, or 270 degrees, and a mirror image version of any of those. These were extremely simple to do because the rooms were made of voxels, so any rotation or mirroring was an axis swap or negation on the voxel grid indexing.

There was one additional step: “feature rooms” were emplaced at random locations as seeds for maze generation, and to ensure that essential features like an entrance and exit—or random features like shops and bank vaults—would appear in the maze exactly as often as the game required. These were guided by rules that would, for example, place the entrance room on the top floor and the exit on the bottom, or make a shop have a random chance of being open, closed, or entirely absent.

Every room filled exactly one cell on the maze grid. For larger features like the ziggurat at the bottom of World 1 or the outdoor snow field at the start of the Mountains of Madness expansion, I had to build big spaces out of smaller chunks, and emplace them as multiple feature rooms with fixed locations and fixed transforms. It was pretty gross.

My main goal in Eldritch was to create interesting gameplay space; it didn’t matter much if rooms fit together neatly. The Lovecraftian theme supported bizarre, unknowable geometry, so if two rooms didn’t quite align spatially or thematically, that was fine. It worked for the game! And it turned out to be an essential part of the randomness of the game, as I would find out on subsequent projects where I added more constraints.

Chapter 2: Vamp

With Slayer Shock, the modern real-world setting and procedural mission objectives demanded some changes:

  • I wanted spatially coherent procedural levels; no more random crashed-together Lovecraftian spaces
  • I wanted levels to be any size, not limited to a small 3D grid
  • I wanted rooms to be placed according to a critical mission path, not expanded randomly in a maze
  • I wanted rooms to be any size, not limited to one cell in the 3D grid
  • I wanted rooms to be composed of static geo meshes and navmesh, not voxels

The sum of these needs represented a huge delta from Eldritch‘s generator, and I rewrote nearly the entire thing. The maze generator went away entirely, replaced by a portal-based algorithm of placing rooms one by one, wherever they could fit to connect to open portals from existing rooms. Rooms now defined their available connections by portal tags—for example, a cave portal could connect to another cave portal, but not to a forest portal; and caves and forests could be joined by special junction rooms with a cave portal on one side and a forest portal on the other.

Feature rooms were no longer seeded randomly within a maze grid, but placed in sequence along a non-branching critical path which was laid out before any subsequent room expansion. This was mainly used to place entrances, exits, and junctions between indoor and outdoor areas like caves and forests.

Every region in Slayer Shock had very different requirements, and my codebase got very messy with special case hacks for each. The introduction of so many content-driven rulesets also meant that the algorithm now had the possibility to fail (which was literally impossible in Eldritch as long as there was a complete set of room configurations). And it did fail often, making level generation much slower as it continually restarted with new random seeds until a successful world was found. Worse than that, it meant that viable levels tended to be very similar. I successfully “fixed” the chaos of Eldritch and ended up with something very predictable and bland.

Chapter 3: Loam and Zeta

In 2019, I began developing a side project fantasy dungeon crawler codenamed “Loam”. That project is currently abandoned, though I’m holding onto it because it feels like it could be my magnum opus. But also it being my potential magnum opus is why it’s currently abandoned, because it was extremely overscoped as a thing to work on in my free time.

My primary goal with proceduralism in Loam was to build levels that looked like D&D maps and played like immersive sim levels. I tore out the critical path stuff from Slayer Shock and focused on how rooms were connected within a smaller space. One of the problems that kept coming up was “the door problem”: when two rooms join, where and how do I spawn a door between them? The door spawner has to belong to one room or the other; how do I ensure that there is a door and that there is only one door (i.e., both rooms aren’t trying to spawn at door at their shared boundary)? I eventually decided to use portal tags to enforce placement of small spacer tiles between rooms, and put the doors in those spacers.

I also wanted to minimize failure cases in the level generator. Most failures were due to unclosed room portals: meaning a room was placed with an open exit, but no rooms could fit beyond that exit. I solved that by allowing the generator to conclude its main expansion phase with some portals left unclosed, and then connect those portals via a series of small connective tissue tiles. These tiles are guided by a graph search between unclosed portals, and guarantee closure and connectivity as long as there is a path. The enforced space between rooms provided by the spacer tiles usually affords such a path; and as an extra step to ensure this worked well, I implemented a limited “rewind” of the generator so that spacer tiles which could not be closed would be removed and replaced with connective tiles.

My first game jam to use this algorithm was NEON STRUCT: Desperation Column, but it used an extremely constrained room set so the connective algorithm never kicked in.

Chapter 4: Fray, Lily, and Wolf

Since Eldritch, my level generator had been fundamentally an indoor generator. I faked outdoor space in Slayer Shock (at the cost of huge performance problems), but it was fundamentally designed to connect small convex rooms to other small convex rooms. I wanted to do something bigger.

In 2022, I was working on a side project codenamed “Fray” which could be summarized as “indie Far Cry Star Wars immersive sim”. Yeah, that one was overscoped too. But one of my goals was Far Cry-style outposts: small indoor complexes within a broader outdoor space, that the player can approach from any direction and scope out before attacking. It would require a radical rethinking of not only my level generator but my sector/portal-based renderer as well.

My solution was to use generators within generators. At the outdoor scale, I would generate very large “rooms” on a coarse grid; and then within those rooms, I could generate indoor sublevels comprised of smaller tiles. The most significant constraint—due to the way sublevel and superlevel portals were connected for the renderer—was that a sublevel had to be contained entirely within a superlevel room’s space; I could not use a small sublevel to connect two superlevels. But that worked fine for my Far Cry-esque goals, and I got it working in about a week.

Shortly after that, I got the idea to use room and sector “colorization” to guide room placement, so that I could build levels with sequenced gating: for example, a player must collect the red key and unlock the red door before they can access the red part of the map. I didn’t have a specific goal in mind for this, it just seemed useful and I realized it wouldn’t be too difficult to implement.

I first shipped this version of my level generator in Li’l Taffer. It had no actual outdoor generation, instead using a fixed outdoor space with a single interior generator; but the colorization feature ended up being used to demarcate the public and private space within the mansion the player is tasked to rob.

The broader feature set finally got a shipping use case in Schloss der Wölfe, which is a largely linear experience but used nested generators and region colorization to make indoor/outdoor portaling work for the renderer, to guide placement of entities, and to provide some small variations on replays.

Chapter 5: Rasa and Tofu

Shortly after I released Schloss der Wölfe, I started another game jam—something akin to The Unfinished Swan or Scanner Sombre where the player starts effectively blind and uses a tool to identify the space around them. I ended up bailing on that to focus on Eldritch 2 instead, but in the short time I was working on it, I added “furnish rooms” to my generator.

Furnish rooms function almost identically to sublevel generators (i.e., the indoor parts of an outdoor room), but they do not create new sectors and portals for the renderer. Instead, they just add all their geo to their containing room. This gave me a way to build most of a room by hand but then let the whitespace be filled in randomly.

I bailed on that game jam and returned to Eldritch 2. The last big thing I needed to address to make all of these years of changes work for this game was a problem that had been lingering since Slayer Shock. Ever since I moved from voxels to mesh-based rooms, I’d needed to make sure that navmesh edges fit together precisely so I could stitch them up after rooms were placed. This prohibited me from doing the sort of chaotic crashed-together spaces of Eldritch, because every edge of every room needed to conform to a consistent navmesh signature. I waffled on this for a while, but ultimately decided that the accidental chaos of Eldritch‘s worlds was something I needed to now intentionally repeat. I rewrote some big chunks of my navmesh stitching and pathfinding code, and now my generator will stitch together any overlaps in coincident navmesh edges, to ensure that AIs can navigate between rooms as long as there is any actual space to do so.

I also finally reintroduced two Eldritch-era parts of the generator: mirrored rooms (a whole separate blog post in and of itself because of all the new requirements of mirroring meshes and navmesh, through multiple stacked transforms) and feature rooms, which are now emplaced at two stages: first as seed rooms before the map is “colorized” for gating; and then in a second pass, for feature rooms which may depend on that region colorization.

All of this leads to the current state of Eldritch 2‘s level generation. Levels are formed by a series of nested generators (outdoor overworlds with indoor dungeons, both with rooms optionally populated by random furnish rooms); with optional sequence gating, either within the overworld or within any dungeon; and each nested level seeded parametrically to guide placement of special features like shops and bank vaults. Room placement can still fail at any step depending on the authored room content; but as long as I populate all the common cases and keep the constraints reasonable, it rarely does. And the generator produces interesting levels in under 200ms, keeping load times to a minimum.

Slayer Shock

The One About Slayer Shock

It’s a delicate balancing act being transparent in game development. I’ve seen friends who had the best intentions speak openly about what went wrong in their games, only to have their words turned against them in the streamlined narrative that their game was a failure and they were a failure for making it. It taught me to be guarded. Mainly for that reason, I’ve never said much about Slayer Shock (Steam user reviews: 55%). It was a dud, and nothing I could say would change that. You can’t mea culpa a game into success. But it’s been 7 years now, I’m not going to damage its sales or my reputation by talking about it. I’ve spent a lot of time reflecting on what happened there, I’ve internalized the lessons and made conscious positive course corrections on subsequent projects. I think I actually have something to say about it now.

Vampires in Nebraska

It was 2015. I was wrapping up NEON STRUCT (Steam user reviews: 87%) and thinking about what my third indie game would be. After spending a year feeling out of my element in level design and writing, I was eager to return to the familiar territory of procedural levels and systems-driven gameplay. The central concept owed a lot to an early version of XCOM (the ill-fated 2K project which eventually shipped as 2K Marin’s The Bureau: XCOM Declassified): a strategy-level campaign game combined with a first-person stealthy shooty game. Then I wrapped it in a Buffy the Vampire Slayer skin and sprinkled on some of my own experience growing up in Nebraska, and that was Slayer Shock. Patrol and protect the town, research the vampires, find and eliminate the vampire leaders. The elevator pitch still works for me, I just wish I had made the game I envisioned.

Sometimes Real Life Happens

Through all of NEON STRUCT‘s development (2014-2015) and into Slayer Shock (2015-2016), I was in the middle of an extended separation and divorce. I shared custody of a toddler. I had no family nearby, and I had somewhat alienated myself from my former work friends after quitting and going indie. I felt alone, and I felt under immense pressure, and I didn’t handle it well. I drank a lot, and I created new problems for myself.

That’s not an excuse for how Slayer Shock turned out, but it is the truth. I still believe there was a great idea at the heart of that game, and maybe a healthier version of me could have made it work. But I was at an all-time low and my heart wasn’t in it.

The Scope Monster

Or maybe I just got too big for my britches. After the modest success of Eldritch and the warm reception to NEON STRUCT, I was starting to feel like I could do no wrong. I had great ideas and I could execute on them. I made games faster than anyone. Could I make a stealth FPS with a strategy campaign layer, built for endless expansion and designed to be played for 100 hours? Of course I could! If anyone could do that, it was me.

And that was Big Mistake #1. I arrived at the idea of endless expansion and a 100-hour play time in a few ways. The first—and more legitimate—reason was because of what happened with Eldritch: the game was successful, and I wanted to add more, but I’d painted myself into a corner with its rigid quest structure. The second reason was a more toxic one: I craved success in all its forms, and to me that meant people playing my game for hundreds of hours the way they did with The Binding of Isaac or other roguelikes.

And this is Big Lesson #1. There are only two ways to make a game that people play for 100 hours. Either you make a game that is So Good that people want to play it over and over, or you exploit players’ addictive tendencies. These aren’t mutually exclusive, but I’d rather not do the latter at all. And I didn’t want to do that in 2016 either, so I accidentally set myself up to make a 100-hour game purely on the strength of its content. Oops.

Big Lesson #2 is: if your game relies on future expansions to be good, then it’s not good now. I built a game infrastructure in which I could endlessly layer in additional content on multiple axes. New levels? Yes! New level twists? Yes! New enemy types? Yes! New weapon types? New ammo types? New research methods? Yes, yes, yes! I’ve got a framework for that! I spent so much time building neat little systems without realizing the cost of populating those systems with interesting content. I shipped Slayer Shock in what I considered to be a finished form, but with big plans to grow it from there. Another way to describe that might be “Early Access”. And then I ran out of money and those plans never happened.

Art Is Hard

After making two games with voxel-based worlds, and especially after hearing Eldritch described so many times as looking like a Minecraft mod, I wanted to step up my art game. No more voxels, I was going all in on mesh geo and dynamic lights and physically-based lighting and materials. I had a vision in my head of the style I wanted, and if you’re familiar with Warhammer 40,000: Boltgun, it was a lot like that; but I’m not a good artist and I extremely missed the mark.

As I was nearing the game’s release, I was talking with my brother about the game, and he said something to the effect of: “Eldritch was simple, but it had a style.” And he was right, but it was far too late for me to course-correct. I guess Big Lesson #3 is to know your strengths and weaknesses. I have put in tens of thousands of hours to be a world-class programmer, a great designer, and a pretty good composer. I could do the same for visual arts, but I’m running out of years here. So if I’m not good at art, maybe a better option than making bad art is making the most out of simple art.

The Grind

The core loop of Slayer Shock isn’t bad per se: sneak around an environment, dispatch some vampires, grab some goodies, and get back home. For one or two missions, it works pretty well. But it quickly gets tiresome.

Big Mistake #2 was my assumption that if replaying levels in a roguelike is fun then replaying levels in a campaign-based game would be equally fun. But there’s a psychological element I hadn’t accounted for. When you replay a level in a roguelike, you know you’re playing it again, from the start, and you’re challenging yourself to do better this time. Roguelikes trade player character progress for player progress. Your character doesn’t get better over time, you do. But if the game takes away permadeath, and you keep playing variations of the same level over and over in pursuit of some unclear finish line, it doesn’t feel like progress. It’s a grind.

I hoped to offset this sameness with level twists, but (see Big Lesson #2), I didn’t have enough of those to make a meaningful difference. And maybe I could have changed the player build model so that players didn’t grow into and then stick with a single loadout for the whole game; but none of that really addresses the psychological element of the game structure. Big Lesson #4 (which is a corollary to Big Lesson #1): if your game asks players to replay content—even if that content is randomized—you sure as heck need to make sure they have a good reason to care.

What Went Right

I shipped a game, and that is a miracle, because every game that ships is a miracle.

Eldritch Eldritch 2 NEON STRUCT Slayer Shock


I’ve been developing games professionally for 17 years, and I’ve been developing my personal engine Rosa for about as long. This isn’t going to be a post about whether or not you should make your own engine. I generally wouldn’t advise it, but you should make your own decision. I made my decision a long time ago. I love making games, but I love programming too; and engine development provides some of the most satisfying programming challenges. This is a brief history of Rosa and my current ideas for its future.

The origins of Rosa came from my student work at SMU Guildhall (2005-2007). As part of the curriculum, every programming student had to build their own 3D game engine, with OpenGL and Direct3D rendering, audio, input, collision and physics, etc. The more game-specific parts of an engine were left to each individual to focus on, and I chose to pursue AI with studies on behavior systems, awareness models, and pathfinding. This was my first time writing a 3D engine from scratch, and I got it done but it was messy.

When I graduated in 2007 and became a full-time professional game developer, I also began building a new personal engine, taking the good parts of what I had learned and cleaning up the messier, poorly-architected bits. Incidentally, I jettisoned OpenGL at this point, believing Direct3D to be the way (and Windows to be the only OS). I did this work mostly for fun, but I also hoped to eventually make a game of my own. Between 2007 and 2012, I built a lot of engine parts without ever getting close to actually shipping a game.

Brass City Couriers (unfinished, circa 2009-2012).

I leaned on Blender heavily at this time, even using it as my level editor because that seemed easier than building a level editor. The lighting model was baked and static, encoded into level geo as vertex colors and applied to dynamic meshes through a coarse volumetric directional ambience grid. Game objects were inheritance-based. Development was slow.

Codename “Agency” (extremely unfinished, circa 2012).

In the summer of 2011, I was frustrated with the inheritance model of game objects and decided to experiment with this fancy new “Entity Component System” concept I’d been hearing about. I was also eager to explore procedural generation, for reasons I don’t quite recall but probably had something to do with Minecraft. I built a simple textmode graphics framework and began building an infinite procedurally-generated world populated with composition-based objects. It was fast, it was fun, and in retrospect, it may have been the most important step I could have taken in my career.

Second Order (unfinished, circa 2012).

In early 2013, I left the relative security of my Big Commercial Games job and went into business for myself. (A few months later, my brother did the same and we formed Minor Key Games.) I had a very limited budget and needed to ship a game in around 8 months. The obvious choice might have been to lean on all the tech I had built over the prior 6 years, but instead, I ripped it all up and streamlined everything. I used the simplest possible art and rendering: all albedo, no normal maps, no specular lighting. I rewrote my collision code for AABBs exclusively, because it’s fast and simple and I was using voxels so everything was axis-aligned anyway. And I incorporated some ECS concepts to make game object composition and reusability a breeze.

Eldritch (2013), Minor Key Games.

My engine didn’t have a name at this time, but I’ll call this Rosa v1. Eldritch was a modest success and I followed it with my Thief-meets-Deus Ex cyberpunk stealth love letter NEON STRUCT. I didn’t make many engine changes for Neon; I improved my tools and optimized the voxel lighting grid to support turning lights on and off at runtime, but it is fundamentally still Rosa v1: all albedo, with voxel worlds.

NEON STRUCT (2015), Minor Key Games.

By the time I finished Neon, I was growing tired of Minecraft comparisons. I liked the ease of working with voxel worlds, but I couldn’t escape the shadow of the king of voxels. I was also starting to feel constrained by how much I had cut my engine to the bone; in particular, I was constantly working around the lack of dynamic lights and eager to rebuild my rendering skills. I undertook a substantial overhaul of my engine during development of the next game, removing voxels in favor of mesh-based geo and replacing the simple forward renderer with a deferred renderer using a principled physically-based lighting model.

Slayer Shock (2016), Minor Key Games.

My engine still didn’t have a name, but I’ll call this Rosa v2. Slayer Shock missed the mark, but that’s a story for another time. I ran out of money around the end of 2016, got a job, and largely put my engine and my games aside for a while. From 2017 to 2020, I dabbled in a couple of projects but ultimately got nowhere. But while copying code back and forth between a couple of projects and renaming classes to match the project, I realized that it would be easier if I had a unifying name for game-level classes in my codebase. So instead of renaming top-level classes like EldritchFramework to NeonFramework to VampFramework, all my games could use one common codename. I picked “Rosa” because it was like tattooing “MOM” on my arm, and that became the de facto name of my engine.

In 2020, stuck inside while a pandemic raged on, I started doing game jams to scratch the indie dev itch. I finished four game jams that year, and have done at least one every year since. These game jams culminated in what I consider a trilogy of minimalist first-person games: NEON STRUCT: Desperation Column, Li’l Taffer, and Schloss der Wölfe. Each of these improved upon my engine’s pipeline and workflow, largely by leaning on procedural generation. I developed tools to quickly generate procedural meshes and materials for world geo, and I reinvented my procedural level generation algorithm to create indoor spaces nested inside larger outdoor spaces. These three games also share a common visual style which I’ve been calling my signature “toy aesthetic”.

Schloss der Wölfe (2023).

I consider this current generation of the engine to be Rosa v3, and it is the engine I am now using to develop Eldritch 2. It combines the fast iteration and relatively simple art pipeline of Rosa v1 with the physically-based dynamic lighting and materials of Rosa v2. It’s a joy to work in, and work on. My current work is revising my procedural level generation (again) to bridge the gap between the more spatially plausible worlds of my recent game jams and the intentionally bizarro crashed-together spaces of Eldritch.

Looking to the future, there’s at least one unavoidable tech task that I need to deal with. Rosa is still using Direct3D 9 and OpenGL 2, absolutely ancient graphics APIs that have increasingly fragile vendor support. I don’t feel the need to upgrade for any particular modern features—I’m actually rather happy working with 20-year old tech—but OpenGL is no longer supported on Mac and getting a modern Windows PC set up to build a Direct3D 9 app requires jumping through a lot of hoops that they would clearly developers not do anymore. I’ll have to port to Vulkan eventually, and probably Metal if I ever want to target Mac again.

That’s a lot of words, and I’ve barely scratched the surface of my engine. I’ve got some tech that has been largely stable since as far back as Eldritch: AI behavior trees, event + reaction gameplay scripting, collision detection and sweeps/traces. I’ve got a custom cook process that is fast as heck. I’ve shipped 13 games or game jams on this engine, and it has grown a lot along the way. And I’m excited to keep using it!

Slayer Shock

Everything I Need to Know About Writing Video Games I Learned From Pro Wrestling

I’m currently working on Slayer Shock, a role-playing shooter about hunting vampires in Nebraska. This game is thematically structured like a television series: each mission is called an “episode”, a group of episodes is a “season”, and each season ends when the player and their team stands victorious over the latest villain. (To be clear, that’s just flavor; this is not an episodic game in the usual sense.) The core elements of the narrative—heroes, villains, and plot points—are randomly chosen or procedurally generated to create unexpected stories.

While interactive game systems can generate thrilling player stories, they’re historically less successful at creating characters and plots with the charm and feel of authored stories. I knew from inception that if the narrative aspect of Slayer Shock were to be a unique selling point, interesting game mechanics were not enough. I would need to develop a separate system for generating memorable characters and coherent, engaging storylines. This isn’t without precedent—Dwarf Fortress builds massive mythologies, and Middle-earth: Shadow of Mordor creates memorable rivals—but it is not clearly solved for all purposes in all kinds of games.

In particular, the procedural and strategic structure of Slayer Shock means there is effectively no end to the narrative. Victory over one villain progresses to a confrontation with the next, allies join or depart according to their personal desires, and the game has to manage those events and try make it all coherent. To invent a narrative generator that could accommodate these demands, I would first have to understand how to write an infinite number of perpetual stories.

For research, I first looked to scripted television series (like Buffy the Vampire Slayer, which informs much of the tone and theme of Slayer Shock), but I found it difficult to extrapolate any general lessons from that format. Most television keeps its stories contained to the episodic unit, with big picture season or series plots developed in the margins, in ad hoc ways. While the reliable structure of “monster of the week” shows or procedural dramas could be instructive for other kinds of story generators, I found that they weren’t helpful for my purpose. I realized I wasn’t actually interested in the content of an episode, I was interested in what changed between episodes.

My next brief research stop was at soap operas. With their relentless development schedule (typically producing 5 hour-length episodes each week), melodramatic characterization, and penchant for twists and cliffhangers, I was sure there would be a wealth of available research on the structures and patterns and tropes of daytime serials. And perhaps such research is out there, but a cursory TV Tropes search didn’t return what I wanted. And, no offense intended to fans, but I wasn’t excited about the prospect of watching hours of soaps to internalize their design.

Around this time, I watched Max Landis’s “Wrestling Isn’t Wrestling” film*, and so my research path finally led to professional wrestling. Sometimes dismissed as “male soap opera” (a statement with so many layers of problems that I’m not even going to attempt to unpack it now), professional wrestling does in fact exhibit many of the same properties as daytime serials: a staggering amount of content produced every week; frequent, seemingly arbitrary twists; and exaggerated, simply-drawn characters. And as with soap operas, I could find a lot of information about specific plots, but relatively little about the general patterns of story development. If I wanted to understand the narrative design of pro wrestling, I was going to have to study it myself.

Note: For the purpose of this article, when I say “professional wrestling”, I’m talking about WWE’s mainstream version of “sports entertainment”. There are lots of forms of professional wrestling, but the exaggerated characters and angles of WWE are what I found useful to deconstruct for this purpose.

As a child of the ‘80s, I grew up with a vague awareness of pro wrestling, mostly by way of occasional appearances in video game magazines. Wrestling became unavoidable during WWE’s “Attitude Era” in the late ‘90s, and I could identify all the big stars despite never watching a single minute of it. I didn’t understand the appeal at the time—it’s fake, why watch a match where the outcome is predetermined?—and it wasn’t until I finally dug into it last year that I realized what everyone else already knew: it isn’t about the matches per se, it’s about the performances and the storylines. It’s theater.

The first narrative challenge I faced in Slayer Shock was how to make generated characters unique and memorable. My fear was that each villain would be interchangeable with any other villain; perhaps visually unique thanks to a randomized appearance, but functionally and emotionally identical to the rest. Here, I found wrestling especially instructive. Wrestling promotions face a similar challenge to develop a constantly shifting roster of dozens of wrestlers into distinct characters that can get “over” with the crowd. How does wrestling distinguish one bulked-up shirtless man from the next? They give them gimmicks.

The term “gimmick” encompasses everything that transforms a wrestler (i.e., the real person) into their character: behaviors, catchphrases, costumes, and more. It’s the supernatural horror of the Undertaker, it’s Stone Cold Steve Austin’s middle finger salute, it’s The New Day spilling out of an oversized cereal box in anime armor and unicorn horns.

The takeaway isn’t to craft a unique gimmick for every generated character, because that would be impossible. Instead, what I learned was to develop a library of common gimmick elements that mainly serve to distinguish one villain from the next. From that seed, I can let the characters grow in the player’s mind based on the actual events of gameplay. Even in wrestling, the best gimmicks take time to develop and get “over” with the audience; many wrestlers begin with either minimal characterization or with common, tropey gimmicks.

The second lesson I learned was repetition. When wrestling finds an angle or a gimmick or a feud that works, they milk it dry. Sometimes this is tedious or boring: characters reiterate their ongoing angles in promo after promo, the participants of upcoming or recent title matches are repeatedly thrown into the ring again with no meaningful outcome, and the commentators do little more than remind the audience of the wrestlers’ gimmicks. But the reasons for this repetition are manifold and valid. It makes it easy for new or returning viewers to catch up on the storylines. It ingrains the gimmicks in the audience’s minds. But most importantly, wrestling is theater. Everyone involved is performing live for a crowd who showed up that night to see their favorite wrestlers. And from this perspective, it makes no more sense to criticize wrestling for its repetition than it would to criticize a band for playing their most popular song at every concert.

My takeaway from wrestling’s repetition is about how to maximize the limited narrative bandwidth in this particular game. With its procedurally generated levels, there is little room for narrative delivery during core gameplay in Slayer Shock. Plot development happens at the margins of gameplay, in between missions, just as it mostly happens in between matches in wrestling. With such limited opportunity for narrative content, it is critical to reinforce characters through repetition, and there is little time left over to substantially develop them beyond that.

Furthermore, the performative aspect is increasingly significant in games, except in this case, it’s not the developer performing to the player. Instead, it’s the developer and the player collaboratively performing to viewers on YouTube or Twitch. Here again, repetition can help ease viewers into the experience and provide unique memetic hooks for each audience.

My previous project was NEON STRUCT, a game loosely inspired by the excessive reach of the modern surveillance state. Worried that I wouldn’t do the subject justice, I labored over every line of dialogue, struggling to make the script cohesive and coherent, trying to force the game to fit the message.

With that in mind, the third guidance I find in wrestling is adaptability. Wrestlers get taken out of action unexpectedly due to injuries or personal reasons, but the show must go on. On any given night, they may feature anyone from supernatural beings to ex-MMA fighters to literally Donald Trump; but they always have to bring it back to two people grappling in a ring. To be fair, wrestling avoids tackling highly-charged political subjects like the surveillance state, but I actually believe the audience would buy it if they tried.

What I take away from wrestling’s occasionally astounding incohesion is that it doesn’t really matter. As a creative artist, I can take a hard turn and my audience will follow along if they’re on board with what I’m doing. The player and the viewer come to be entertained, and it’s always better to surprise them than to bore them. If they poke holes in the construction or logic of a scene later, at least I’ll know it comes from a place of passion instead of disdain.

And speaking of taking a hard turn, the final point I’d like to share about wrestling is the many ways I’ve seen that the wrestling industry mirrors the video games industry, and what we might take away from that.

  • Like video games, wrestling is mass market entertainment that has grown by expanding into films and other media.
  • Like video games, wrestling is largely delineated between a few major promotions (like WWE) and a vast host of independent promotions that you’ve probably never heard of.
  • Like video games, wrestling has a majority of casual fans who are generally unaware or uninterested in what is happening in the independent scene.
  • Like game developers, wrestlers often bounce between the majors and the indies, for a variety of reasons.
  • Like game developers, wrestlers are intensely passionate about what they do.
  • Like game developers, wrestlers often accept low salaries and strenuous schedules for that passion.
  • Like game developers, wrestlers on the independent circuit are usually not making a living wage from their work.
  • Like game developers, wrestlers can burn out young, and struggle to find similar meaning outside their industry.
  • Like game developers, wrestlers are real people who make long-lasting friendships in their work.

Of course, the same could be said of novels, music, film, comic books, or virtually any other creative pursuit. I don’t mean to imply that all these fields are the same, and I certainly don’t believe that all these properties are good things. What I do find reassuring about it—in a year when the sustainability of independent game development looks uncertain for so many of us—is that our medium isn’t unique, and it isn’t going away. Opportunities may come in different forms than we’re used to, and we may have to look for the open windows when the doors close. But if an industry built around sweaty men in briefs slamming each other into the ground can remain a staple of entertainment across the US, I think we’re going to be just fine.

Slayer Shock will be released in Q4 2016 for Windows, Mac, and Linux, and is currently on Steam Greenlight.

23 July 2019: When I wrote this blog three years ago, I was unaware of accusations against Max Landis. Since then, he has been credibly accused as an abuser, and I do not wish to endorse him or his work. I have left the original text intact but removed the link to his video. These days, I recommend Super Eyepatch Wolf’s wrestling videos instead: