How modern games aren't really retro, but retro-styled technology powerhouses
There is something mesmerizing about big, jagged monsters trying to eat a player's face. There has to be, because retro-styled games are all the rage: last year alone, billions of picture elements (pixels, you know) powered hundreds of indie game successes. Gazillions of blocky faces were eaten.
Would it surprise you to know that you're not actually enjoying retro graphics, but rather retro-styled graphics? To the untrained eye, there is no difference between Mario Bros and Super Mario Brothers on the 3DS. The trained eye, when it's not laughing hysterically in its straitjacket, knows better.
Technology advances all the time, and what you're seeing today happens to look like pixels and sprites, but is computed on dozens of layers of technology that give us sub-pixel scrolling, true transparency layers, and a lot of stuff that the good old days just had to either live without or cheat around. Unity3D is astounding in its ability to provide the freedom to engage in both retro stylings and ridiculously high-tech back-end services.
When we worked on Deep Horizon, we were surprised by some of the advanced technology that went into our little retro-styled game, which one Greenlight commenter already wisely said looks like "a gamemaker tutorial. Those are free.".
Let's take a look at some of those powerful technologies pushing our pixels around, shall we?
Put the pitchforks down. We know that pixel graphics just aren't supposed to be made pretty. Lens flares ruin the delicate purity of pixels, which are hand-crafted in monasteries by men who dedicated their lives to the quest for the perfect square pixel shape, right?
Well, yeah. Lens flares are a bit much, admittedly, but there's nothing wrong with some colour correction, and one or five layers of post-processing effects, because they make stuff look awesome.
Here is a Deep Horizon screenshot, from the very first level:
We run two primary post-processing layers: a color correction pass, and a series of filters that add chromatic aberration, a little vignetting, and some camera distortion. The distortion is animated very subtly so that it gives a gentle impression of rolling waves. Not so much that you'd notice, but enough that when you stand still, you can perceive some peripheral movement.
Every element we use, except for the colour correction, is part of Unity's built-in post-processing effects.
This is what the game looks like without all that:
Pure, right? Beautiful pixels, as they're meant to be! Well, not quite. You see, the second post-processing layer is still active, and it primarily does some colour correction and bit of s-curve saturation. What the game art actually looks like is this:
It's strong, good art, and I'm sure many would prefer it. But it does look blander, and less underwatery. Our greatest artistic accomplishment is when an artist said "wow, you do need help with your graphics, you weren't kidding", so we're not trying to start a "pixel is truth is beauty" discussion, but we're simply illustrating that even simple, retro-looking graphics can have a powerhouse of processing behind them. The next one, you're going to love.
In the beginning, there was the grid. The grid was good. It served as render buffer, as mathematical representation of your entire game world, and it drove the logic and movement of all your characters. The grid was everything. In case it's not clear, exactly 100% of retro games (and a whole bunch of new ones too) based all their internal logic on some kind of Excel-style array of elements. Grids. Then, you know. Resolutions got large, and game developers started enjoying sanity in complicated situations.
There is nothing surprising about technology evolving. In every game you've ever played, sophisticated state machines or behaviour trees drive all basic decision-making. Usually that decision is about how hard the monster should eat your face, for example. Most Deep Horizon fishes are simple state-driven track-and-chase behaviour agents, with just some background collisions checks added in. Heck, most game logic backbones are essentially AI state machines, which means that even your basic start menus and loading screens rely on some kind of AI programming. There's nothing particularly remarkable about that, because artificial intelligence is such a pervasive modern technology that it's not surprising to see it in the works of a lot of things.
However, then there's the boids in the background of Deep Horizon.
See those colourful fishes that feature in all our screenshots and videos? They're just a background effect. They also happen to be driven by what is easily the most complex single function of the game: a state-driven boid-type flock that responds to the presence of the player by going into a flee state.
Now, say what you will, but there's nothing retro about that. In case it wasn't clear, those dumbest little background fishes are the cleverest thing you're going to play in a retro game today, and they don't even matter to the gameplay itself. That's just how metal we are.
You're used to hearing physics-driven when it comes to games, retro- and modern-styled. Instead of programming every interaction by hand, these engines rely on powerful engines that calculate the position, rotation, speed and physical boundaries of thousands of objects at a time, like nVidia's own Physx. Usually that means an imprecise controller that slams you to walls against your wishes "because that's how jetpacks work". At best, it's a fantastic application of rigid body mechanics (that's really complicated tech speak for "boxes and balls slamming into each other and falling over") like Angry Birds.
The use of physics in game engines is again nothing new, and quite commonplace. What we constantly underestimate is just how pervasive physics functions are.
Back in the day, when pixels were pixels and coders were real men, collisions and world interaction would be handled by massive (or not so massive) grid logic processors. There's nothing wrong with that, but they required a lot of abstract steps that could go horribly wrong.
These days, even when no balls are bouncing around your level, all that is handled by physics. Colliders are used to delimit geometry areas or pick-ups. Raycasts are often used to check the position and upcoming collisions of your objects, and in fact collision detection is about 90% of what a modern game engine uses physics for, even if it's not triggering any of those annoying bumpy, bouncy mechanics.
Colliders are generated, attached to level geometry and then baked into more manageable meshes, so that the system doesn't have to deal with hundreds of individual boxes. Pickups have collider areas, and death hazards too. It's all physics-driven, even though nothing at all about the gameplay or controllers relies on physics.
These technologies are powerful, shiny and modern, and their implementation in modern engines such as Unity3D makes it easier to develop games that fulfil that retro style that audiences dig so much, but with none of the pain of actually dealing with ancient packing and file format limitations, or gameplay and logic restrictions based on the fact that your character just doesn't know where the heck it actually is.
Game development is a rapidly evolving discipline, and new stuff always keeps changing our work. The only thing that doesn't change is the pursuit of fun, and rockstar-level recognition from groupies the world over.