This past week, Valve unleashed their "Perpetual Testing Initiative" for Portal 2, both a level editor and mod distribution network for their customers to take advantage of.  Already, thousands upon thousands of levels have been contributed, and while content varies dramatically in quality as with anything user-created, it's fair to say that players will be creating new levels for Portal 2 for months to come, and there is a near-unlimited amount of game content Valve is effectively providing to their fans "for free" (and I admit, I've been making quite a few myself as well).

As much as I'm thrilled by this prospect as a gamer, I'm even more intrigued as a content creator by what the tools are able to offer not just amateurs, but even professional designers.  While development tools have become much more readily available and easy to learn over the last console generation, the Portal 2 editor is the first one I've been able to pick up and start producing what I'd call good, playable content within just a few minutes.

Disclaimer: I am not a programmer, and the things I say here might come across as short-sighted, ignorant or patently incorrect.  I apologize if this is the case.  My goal here is only to illustrate and make arguments from the perspective of a designer.

Tools Should Be Easy

Unfortunately, even today one of the biggest obstacles for a designer to get into the games industry is the general impenetrability of the tools.  Someone might have one of the best creative minds out there, but even creating basic game content can be a big challenge, even with the most accessible tools around.  It certainly would not surprise me to hear that there are many veterans with SDKs like Unreal and Unity that still have no idea at all how to do certain things, or how to take advantage of certain shortcuts.

These dev tools can still ultimately resemble 3D modeling programs and other complicated software, despite the vast majority of functions simply not being necessary for 90% of the work involved in creating games.  Multiple viewports, dedicated toolbar buttons for each and every action, arcane and obscure keyboard shortcuts to speed things up... it's all great to know, but the barrier to entry is exceptionally high, and any time something new needs to be done, there's a whole new learning curve thrown in.  Sometimes it can take a week or more of practice just to get to grips with a single piece of an SDK, and that's not efficient.

UDK's Content Browser is still overly complicated and cumbersome.  I can't count the number of times I've made duplicate versions of files, saved them to the wrong databases, and even had entire levels go to waste because of its unintuitive UI.

 I love using SDKs, regardless of what I'm making.  It's a lot of fun to put things together and the sense of satisfaction upon creating a level that looks good and plays well is immense, even if it's extremely small and simple.  But, even so, basic tasks can often take too long, and sometimes more time is spent just wrestling with the interface or waiting for numbers to crunch behind the scenes.  Blocking out a scene in CSG using Unreal for basic gameplay prototyping can take only a few minutes, but making changes might require re-rendering the lightmaps, pathing, compiling scripts, and any other number of activities, many of which might all require separate inputs.  If something goes wrong, it's often not clear what, why, or how to fix it.

For all the power available, sometimes I just want to move an object a few feet and re-test gameplay, or add a few objects to pretty a scene up... and doing so can require several minutes of waiting or longer in the worst cases.  There has to be a better way of handling things without giving up that power.

Tools Should Be Design-Driven

Portal 2's level editor goes one step farther than Unity, Unreal and others.  Whereas even some of the best tools around are often created from the mindset of "how can we put as many features together as possible?", with little care for intuitiveness, Portal 2's editor is firmly focused on intelligent organization, quick and easy shortcuts for the most common actions, and is generally build to enable designers to create content as quickly and easily as possible, with as little learning curve as possible.

Although it only works in a simple grid and allows for the manipulation of fixed blocks, and thus has a lot of limitations, actually using it could not be simpler.  Adding walls is as simple as clicking and dragging, or selecting faces and pressing the + or - keys.  Gameplay objects can be added to a scene from a simple palette in a matter of seconds, and rather than using scripting, simple relationships can be plotted out using right-click context menus.

Portal 2's tools might be bare-bones, but the speed and ease at which quality gameplay can be created cannot be understated.  For designers who are fed up with fighting buggy UIs and spending a week to learn how to make an elevator, this is the holy grail.

The benefits are immediate and obvious.  Whereas a level in Unreal might take a few minutes to put together and then test out, Portal 2's tools allow designers to literally create entirely function game levels within seconds.  The learning curve is exceptionally easy, and the limiting factor on creating good content comes down to design, not tools, within jut a few minutes.

What this mostly comes down to is a sensitivity towards what designers actually want to do with the tools they're given.  Let's face it, if you're just building a level and aren't involved in scripting, creating game assets, programming, and so on, the most common thing you'll be doing is building base geometry and adding detail on top, tweaking, tweaking and tweaking some more, testing as often as possible, until something looks right.  Then, you'll probably tear down half of it when you realize something's broken or doesn't work well.  Most SDKs I've used have made this cumbersome and awkward to do, even with all the grid-snapping, multiple viewports, etc. available. Most of the time, less is more.

When it comes to building gameplay, it's also fair to say that the vast majority of the time designers will be placing oft-used objects and entities with fixed functionality - placing enemies, trigger zones to create those enemies, creating buttons that open doors, and so on.  It's one of the most time-consuming parts of game development, and yet the interfaces of SDKs rarely lend themselves to doing this quickly and effectively.  Yet, to do something as simple as make a sliding door in Unreal, it could take me several minutes.  In Portal 2, even complex logical interactions between objects can be set up in mere seconds, and the emphasis suddenly shifts from creating a game, to designing one.

Obvious Limitations

It goes without saying that Portal 2's tools, as exceptionally easy and fun as they are to use, are also extremely limited.  They only work with one game platform and one engine.  They only let you make one type of game to begin with.  They have a very fixed number of functions and tools available.  It's impossible to do very complicated scripting, cutscenes, etc.  It's tied to Valve's infrastructure.  Obviously, I'm referring to the UI concepts more than I am to the current implementation and feature set.

Looking past that though, there are still some concerns.  How do you reconcile such tools with existing tools and game technology, and are there any barriers to compatibility?  How do you get new assets into it?  How do you script something?  How do you do your keyframe animation?  What if you want to add more detail than what the tools allow, or plug in a new piece of software?  There's an argument to be made that professional tools are as complicated and imposing as they are because they need to be that way.

Despite being quite limited, there's also no reason why levels created in simple Portal 2-like tools couldn't be brought into other, more powerful SDKs when needed, or why there simply couldn't be a more design-driven UI on top of existing tools.

I admit, those are fair concerns.  However, I think it's also fair to say there's no reason why so many other development tools are so complicated.  There's no need to have a bloated interface full of functions that are useless most of the time, or to hide important functionality within a menu that can only be opened by an obscure key combination.  There's no need to force designers to define obvious parameters when the default option is almost always going to be the best one anyway.  And there's certainly no reason why development tools have to take on a one-size-fits-all approach to their interfaces.

Sure, there is that 10% of time where a designer won't be able to do something with what's available... but for the remaining 90%, building game content is as simple and effective as can be.  In my opinion, that's a very, very good trade-off if it means that 90% of the time is more productive, and more fun for that matter.

Closing Thoughts

Some designers might scoff at the fact that these tools intended for general consumers, and might even look at such a package as being overly simplified compared to the "real thing," but I think even the most hardened professionals should be able to appreciate just how fast and easy it is to create gameplay that is fun and engaging.  Even if, theoretically, such tools were to somehow reduce what's possible in creating game levels, I'd almost say that's already worthwhile simply due to how much time you'd save otherwise.

I certainly wouldn't be surprised if Valve's own designers use similar technology to build Portal 3 and other subsequent games due to how quickly they'll be able to prototype, before taking it into their full editor in order to build release-quality visuals and implement the finishing touches.  After all, the process isn't at all dissimilar from what other tools already do... it's just much, much quicker and lacks the steep learning curve and interface challenges.

I've written before on the state of tools in the gaming world, and while things are definitely better than they were a few years ago, I think that Portal 2 shows we have a long way to go before game level creation is able to transition from technology-driven to truly design-driven.