Designing Good-Looking Prototypes
When I started designing games my ultimate goal was not publication, but rather to simply make a very polished “production quality” prototype that would be SO GOOD that it would become a staple of our rotation at weekly game meetups. I wanted people to play it just because it was as enjoyable as “real” published games and not because they were my friend or owed me a favor.
A big part of this, as I quickly realized, was having a very polished visual appearance.
Since those days the focus has changed quite a bit of course, since publication is now a very real goal. The concept of making good-looking prototypes, however, has remained the same. I would even say that it’s even more of a goal now, since the more I design games the more I realize that a truly good visual design is a slow process and the sum of many small tweaks over a long period of time – that means starting early is best.
One of the prototype player boards for Vel Winter, showcasing a very simple yet visually attractive design.
User Interface Design
While the aesthetics of the game are important and certainly contribute to people wanting to try the game (and enjoying it once they do) that’s only part of the story here. How a game is presented to players, that is the “interface design” if you will, is hugely important for not just the looks but also the functionality of the game. This includes things like colors and font sizes and layout, and also includes more advanced things like subtle reminders of how the game works.
All of this has to be designed and iterated upon, just like the actual game mechanics. Even if your ultimate plan is to have a professional graphic designer figure most of this out it’s still on you to at least come up with a wireframe of how information will be arranged – even the best graphic design in the world won’t help if you’re trying to fit 10 lines of text on a 2-inch tile that needs to be readable from across the table.
That brings to me to a very important point: taking the time to actually lay out the components in a realistic manner very often will expose problems with the user interface of your game, things that are much better to catch early rather than late.
That example above of the tiles across the table is not random, it’s something I ran into with one of my early prototypes. Another (from that same game) involved having technology trees on personal player boards, which was all fine and well until it became apparent that players were either going to need a magnifying glass to read them or the personal player boards would rival most full game boards in size.
The bottom line is that how the mechanics FEEL (especially to players not familiar with your game) is as important as how they actually work. Often we say that mechanics are “clunky” – sometimes this is because of the mechanic itself, other times it’s simply because of how the mechanic is presented. For instance, some forms of randomness is better handled by dice and not shuffling cards, and for other forms the opposite is true.
Balancing Visual Design and Iteration Speed
The main argument against making polished designs is that it takes time. It’s much easier to draw some black and white rectangles and print words and start playtesting than it is to invent icons and layouts and so on – and indeed, the very first prototypes for a game SHOULD be super basic and just barely playable to keep iteration fast. I myself have even gone so far as to not even print anything, opting instead to just scribble on some cards and shuffle up.
A good rule of thumb is to spend time polishing the visual design when you’re ready to make the jump to introducing the game to other people, especially non-designers. At this stage you’ve hopefully done enough solo playtesting to have a solid vision and direction for the game and there’s little chance that you’ll end up throwing the whole thing out.
It’s also very important to note that this time spent on visual design can be applied intelligently, meaning that you spend more time on the parts that are least likely to change.
Consider for instance a game about city building, where you spend resources (represented by square chipboard tiles) to build buildings (represented by cards). The buildings would probably be pretty complex and are likely to change significantly (they may have types, abilities, restrictions on where they can be built, secondary costs or effects, etc) and each of those changes will very likely impact the layout in a non-trivial way. On the other hand, the resource tiles are very unlikely to change – after all they’re just an icon and maybe a name. Investing time designing those tiles is going to pay off across EVERY iteration of the prototype going forward, making them a much more efficient upgrade.
A Quick Demonstration
Of course, making stuff that looks good and doesn’t take forever to make is easy when you’re already a graphic designer to begin with (like I am), and much harder when you aren’t. I can see a lot of people reading all the above and saying “well that’s really great in theory, but I can’t draw my way out of a paper bag so it’s completely irrelevant”.
In reality basic graphic design is not very hard at all. “Good looking” and “polished” does NOT necessarily mean “complicated”. There’s a trending design theme in software called “flat design” that is built on the tenets of simple shapes and colors without complex effects like gloss and shadows. For some real world examples see the Metro UI introduced in Windows 8, and the recent direction of Apple’s iOS interface design. For a game-related example look no further than Overwatch, which goes so far as to even omit colors from ability icons, keeping them a solid white instead.
The user interface of Overwatch, using very simple flat icons to great effect.
So let’s do a quick demonstration, using resource icons as mentioned before. Assume these are going to be square tiles for the purpose of this example.
First we need some icons. There’s a wonderful repository of free icons on http://game-icons.net/, which may not always have EXACTLY what you’re looking for but should be more than enough for prototyping purposes. All icons are available as a transparent PNG and at a pretty large size, so you don’t have to mess around with vectors and special software (though if you DO want to do that then they’re also conveniently available in SVG).
Next let’s get some colors. Luckily “flat UI design” is a pretty robust concept, and comes with a certain visual style when it comes to colors (just do some googling, you’ll immediately see hundreds of very similar-looking examples). The most basic color resource for this is https://flatuicolors.com/, which contains a number of common colors pre-selected for easy reference (just click the color and the RGB hex code is automatically copied to your clipboard).
After that, just combine – choose two colors that work well together, one for foreground and one for background (remember that generally all the light and dark greys can serve as a background for anything). Add some outlines, or shadows, or stripes to the background to make it look a bit more interesting, and you’re done – now you have a bunch of nice looking resources for all your prototype iterations.
Here are some very quick examples illustrating the above concepts. These took only a few minutes each to make, and without any complicated Photoshop magic.
That’s it for this time. In the near future I plan to have more articles on the topic of graphic design for prototypes, focusing on speed and simplicity. More specifically I want to do an in-depth article on icon design – the above example can be taken much further with a few additional techniques.
Until then may the first reaction to all your prototypes be “wow, that looks really good!”.
- Sergey Kudria
- July 14, 2016
- 2 Comment