Whether it's a simple game jam entry or a long-term passion project, your game needs to feel alive in the hands of players. In this tutorial, I'll share ideas for bringing your game to life, and demonstrate what happens when you apply every one of those ideas to a simple game demo.
Check Out the Demo
Click the demo to give it focus, and then use the arrow keys to move, X to shoot, C to jump, and N and P to switch between different iterations of the game.
Watch the Video Tutorial
This is essentially a video summary of the demo and the tutorial. There's more detail below!
This tutorial will walk you through the creation of a very basic game, showing the thought process behind the additions and changes made across 10 iterations to make the experience come to life.
What exactly do I mean when I talk about bringing your game to life? This is one of those game design philosophies that varies greatly across the industry, but I personally define game life as the combination of control, feedback, variation, and permanence. Game life is not all about complex AI and deep, character-driven stories. It’s about how the game responds to your input and how it delivers specific feedback to stimulate your senses and reflexes.
For this example, I’ve decided to go with a basic 2D sidescrolling platformer-shooter. If you’re developing a turn-based RPG, then the specific details aren’t going to apply to your project. But that’s not the point. The importance of this article lies in why certain decisions are made, not the technical implementations of each iteration.
Each iteration of the game corresponds to a specific section below. You can follow along in the provided game demo by switching between the different iterations. This will illustrate how a game comes to life over time through simple, incremental changes.
Iteration 1: Basic Core Mechanics
Ladies and gentlemen, I present to you our hero: Skull Baby. Our hero has been locked in an eternal feud against the evil Slug Boogers, an intergalactic menace determined to take over the known universe. With Skull Baby’s trusty Booger Buster 5000 and relatively average jumping ability, it’s up to you to save the galaxy!
With that, we have our incredibly basic and cliché game idea. Our core mechanics include left and right player movement, left and right enemy movement, a simple jump, and a semi-automatic gun that shoots a bullet that travels horizontally. If the bullet collides with the enemy, the enemy is destroyed. For the sake of this demo, and for testing purposes, the enemy respawns after being destroyed. We use a basic collision system to keep the player and enemy enclosed in the playing area, and the enemy begins moving in the opposite direction after colliding with a wall.
For this example, I won’t be adding a win/loss condition, player health, or even player/enemy collision. Balancing this kind of game in that regard would require an entirely separate article. Game balance is a crucial element of design, but it varies so immensely across genres that it would be a distraction from the main idea. And remember, you’re not playing a finished game in the demo, you’re looking at the decision making process of a few select details.
So our game works, but it’s a horribly bland experience. Let’s start bringing this game to life!
Iteration 2: Adding Animation
It’s such an obvious addition, but just look at how much life is added to the game with a few simple animations.
For the player, I’ve added animations for idling, running, and jumping. For the enemy, I’ve added a walk cycle. With names like Skull Baby and Slug Booger, it makes sense to take a light-hearted approach to animation. Skull Baby bounces and bobs around with a squishy mid-section, while the Slug Booger creeps along with wiggly antennae and googly eyes. It’s important to maintain consistency with the tone of your artwork so that entities in your game world feel as if they belong together.
Here’s where my game design philosophies are slightly different than others. I prefer to create and polish my artwork as I develop the basic prototype. Some designers prefer to use “programmer art” for as long as possible while building the basics of a game. While these animations are not exactly final, they are very close to what I would use in the final product. I do this for two important reasons:
- First, it allows me to see these animations repeatedly over an extended period of time due to the all the testing I’ll be doing. Eventually the flaws of an animation will become more and more obvious, and I’ll feel more compelled to refine and improve it.
- Second, this allows me to build the game around how it looks rather than trying to draw a sprite to fit into the confined spaces dictated by the code. It’s easier to change a few lines of code than it is to redraw a sprite.
Iteration 3: Adding Basic Sound Effects
I'm using this iteration to prove a point, and not necessarily as an example of what I would do while creating a game. By implementing incredibly basic (and arguably bad) sound effects this early in development, the value of good sound effects will become even more apparent in a later iteration.
I've added three sounds: shooting, jumping, and bullet collision / enemy death. By repeating these sounds over the next few iterations, you will better understand one of the most important yet often overlooked aspects of game design: variation through randomization.
Much like adding animations, adding sound effects this early in development gives you enough time to determine whether you like your assets or not. Many developers add sound effects in the final steps of game development. This can be dangerous, because the mere inclusion of sound after hours and hours of silent game testing can artificially inflate your level of satisfaction with the quality of the assets. Adding sounds early also ensures that your audio triggers are in place before you add too many layers of complicated code that may need to be rewritten to get audio working properly.
Iteration 4: Adding Stage Tiles
Again, this isn’t a terribly important iteration at this stage of development, but I was tired of looking at the boring black blocks used to represent the floor and walls.
This is purely a cosmetic alteration of the game because we’re still using the pre-existing functionality of the black blocks. These tiles add nothing to the gameplay experience, yet the game still somehow feels different. Instead of standing directly on top of a 2D block, the perspective has shifted slightly so you can see both the top and side surface of the block.
The collision code is the same, but now the foundation is in place to create layers of depth in the future. I’m using this as a way to prove a concept that I’ll expand on in greater detail in a future iteration: seemingly small cosmetic changes can greatly influence the feel of a game.
Iteration 5: Verticality and the Introduction of Variation
This is where things start to get interesting. In this iteration, I’ve added one of the most widely-used platforming mechanics of all time: the double jump.
Whether it’s available from the start or as an upgrade you earn over time, the double jump is the perfect example of how a simple change can help bring a game to life. But how? It’s just a way to make the player jumper higher and farther, right? How is that anything other than a simple mechanic? Allow me to explain.
Our basic jump has a fixed height and a fixed speed. Some platformers allow you to hold down the jump button to extend the jump height. With our original jump, the player was locked into a decision. Once the button was pressed, the player no longer had a choice. There was no variation. By adding a double jump, we've given the player a choice, and introduced variation to the player’s jumping experience. I’m sure you’ve heard that “variety is the spice of life”; this is also true for game design.
But you can’t just throw in a ton of choices and call it a day. We could give our player a jetpack, spring shoes, a portal gun, and the ability to fly. That would definitely open up the number of choices available, but most of them would become redundant or meaningless. The choices have to be useful in multiple situations, and our double jump passes that test. By adding this basic double jump, we can add verticality to our stages and enemy encounters without changing the core gameplay in the way that a jetpack would. For instance, stage design could remain mostly horizontal for a while, and then the double jump could become required in a section to expand verticality and introduce variety and life to the experience.
And it’s not just about basic platforming. In fact, the number of gameplay choices is immense with a simple double jump. The regular enemy can be avoided with a regular jump. A larger enemy could require a double jump. Maybe a boss encounter would require a combination of regular and double jumps to dodge attacks and reach a higher enemy weak point. A room with spikes on the ceiling could limit the usage of the double jump, while a sequence of sizeable jumps could limit the usage of the regular jump. Throw in the strategic ability of using precise double jump timing to dodge multiple enemy projectiles, and you’ve created hours of gameplay possibilities with one small and seemingly insignificant mechanic.
This demonstrates how bringing life to a game experience isn’t about adding an insane level of polish or detail, but can be about using a small change to create giant, sweeping changes to the core player experience through variation.
And now that you’re thinking about variation, I want to bring up one of the greatest tools at your disposal: randomization. This iteration features a randomized jumping sound, which ensures that the player isn’t hearing the same sound every time the jump button is pressed. It seems like a small change, but the next iteration will expand on this idea to show just how important randomization is when you’re trying to bring a game experience to life.
Iteration 6: Improving the Feel of Gunplay Through Feedback and Randomization
This iteration features quite a few changes, all designed to improve the gunplay, which is the main focus of the game. No matter what kind of game you’re making, you should spend as much time as you possibly can refining the main way your players interact with it. This iteration adds life to the game through an improvement on visual feedback, audio feedback, risk vs. reward, and randomization.
Our previous iterations featured very unsatisfying and underwhelming gunplay due to the virtually non-existent bullet feedback. Pressing the fire button resulted in the creation of a bullet, but that was it. By creating a simple muzzle flash and increasing the size of the bullet, we’ve created a much more satisfying experience for the player. A subtle screen shake is added to emphasize the power of our gun, which now feels more like a shotgun than a pea shooter. Our bullets are becoming a main character, which is incredibly important in a game driven by gunplay.
The boring, puny gunshot sound from earlier has been replaced with a thick and meaty explosion that goes well with our new visual feedback. It’s important to make sure your visuals and audio work well together to breathe life into your game. In the same way that great audio can enhance your game, bad audio can detract from the overall experience.
Risk vs. Reward
In a game that’s all about shooting, many players prefer an auto-fire option. Why is this? Maybe it’s because their fingers get tired, but I would argue that it’s because most shooting games offer no risk for firing a weapon.
Hear me out. If the player is not penalized for firing a weapon in the game, then why even require the player to press the button at all? There has to be reason to press a button, and there has to be a reason to not press that button. Variety is all about choices, right? So give the player a reason to choose to press a button or not, and provide a risk and a reward for both choices.
In this iteration, I’ve introduced gun recoil that will propel the player backwards with every shot fired. Fire too quickly, and you end up flying across the screen. In a stage with pitfalls, spikes, or other hazards, this recoil mechanic creates interesting scenarios where players are forced to choose when, where, and how to shoot. Yes, you can reap the rewards of firing hundreds of bullets at your enemy, but you run the risk of being killed by something you’re not even firing at.
Try to find ways to introduce this concept in your game, and you will find that the number of possible gameplay scenarios get multiplied. For example, this recoil mechanic results in the player being able to jump farther, so long as they are comfortable doing it while traveling backwards. It’s an interesting layer of depth that can emerge over time, adding yet more variation to the gameplay experience.
This is easily the quickest and simplest way to breathe life into your game. As with the jumping sounds from an earlier iteration, the gunshot sound is also randomized. The player will be firing hundreds of bullets at a time, so it’s incredibly important to make this as varied as possible. The trajectory of each bullet is also randomized slightly. We could introduce upgrades over time to make our bullets more accurate, but this kind of game will not require pinpoint bullet accuracy, so this kind of randomization works perfectly.
Iteration 7: Enemy Knockback
Fighting the enemies up to this point has been an uneventful experience. This iteration introduces a form of visual feedback by giving enemies actual hitpoints and introducing a bit of knockback.
When a bullet collides with an enemy, the enemy flashes red temporarily and the enemy is moved in the direction that the bullet was traveling. It now takes five hits to kill an enemy, creating an actual challenge.
The starting animation frame and an enemy’s maximum movement speed is randomized to create variation among the enemy force that has now increased from one Slug Booger to four Slug Boogers. If you have the same sprite on the screen, and the sprites are all instantiated at the same time, it’s important to do this to ensure that there’s some differentiation between the entities.
While these changes make enemy encounters a bit more interesting, we still have a way to go to make the overall experience satisfying.
Iteration 8: Particles!
Remember when we introduced stage tiles, a strictly cosmetic change that added nothing to the gameplay yet still managed to change the feel of the game? Well, adding particles is a sure-fire way to turn that idea up to 11.
Dust particles are emitted when the player jumps and when the player lands, adding a bit of life to the movement of the main character. Fire and a bit of smoke is emitted from the gun barrel every time a shot is fired, and the bullets erupt into an array of white particles when colliding with a wall, floor, or enemy object.
While I was working on this demo, I showed a few teaser GIFs to some of my friends, and the first response was usually the same. Everyone commented on the particle effects, proving just how valuable this kind of visual feedback can be. But it’s not just about being “pretty”; particles can make a game feel more alive by pushing a player’s imagination further into the game world.
We all know there’s no dust on the ground in this game, but the particles can cause you to suspend your disbelief. The same goes for the gunfire. What was previously just a white sprite now feels more like a projectile hurled out of a barrel by the combustion of gunpowder. And now, instead of just disappearing, our bullets can logically disappear from the game world by breaking up into tiny pieces. The starting and ending positions of our jumps are now marked by dust. Everything is starting to have a beginning and an end. Everything is beginning to have a purpose. When these individual objects begin to live and breathe on their own, that’s when the game as a whole can begin to feel more alive.
Iteration 9: Enemy Death and the Value of Permanence
Since things are starting to feel more alive, we should definitely make them feel more dead.
Defeating an enemy should be a satisfying moment, since it’s the main point of our little game. In this iteration, enemies explode into a burst of alien blood particles and body chunks. A white flash and a heavy screen shake accompanies a squishy explosion sound, and the body chunks make a squish noise when they collide with the floor.
These body chunks also bring up another important game design element: permanence. The player can leave a definitive mark on the game world. It’s like keeping a scrapbook of photos to mark the events of your life—except much more sinister. In a way, it’s proof that you were once alive. This simple idea can mark areas that you’ve already been to, and it can be a reminder of the battles you’ve won.
Permanence is incredibly important, and it’s an idea that’s been around since the beginning of game development. Think back to the original Super Mario Bros., where you can see which blocks you’ve already broken. It’s such a simple concept, but it brings your game to life by showing the lingering effects of your invested time.
Iteration 10: Final Touches
The final iteration introduces a few optional visual touches and a simple soundtrack. Although I didn’t take the time to compose a song to fit the visual style of the game, I don’t want to ignore the sheer importance of audio’s role in bringing a game to life. Whether it’s an actual song or some kind of ambient environmental noise, the power of audio to breathe life into your game is immense.
As for the visual additions to this final iteration, I added a scrolling parallax background and more permanence via shell casings expelled from the gun. The parallax background doesn’t make logical sense in this example because all the action takes place on one screen, but you can see that the added layers of depth help to extend the game’s world further back into territory that the player will never be able to traverse.
The industry can seem obsessed with the idea of open world games and being able to reach every visible area of a game’s map, but I say that it’s actually important to feature inaccessible areas in a game. Will you ever step foot on every grain of sand in the known universe in real life? Of course not, and that’s not a bad thing. The vastness of the universe is an interesting concept, so thinking about the unreachable areas of game can be just as intriguing.
A game’s life can be extended well beyond any playable, visible, or audible boundary if you want. The world is at your fingertips, so take advantage of it!
Compare the game in Iteration 10 to the game in Iteration 1. These small, simple changes and additions added up to create a much more satisfying experience. The game in Iteration 1 is boring, lifeless, and uninteresting. The game in Iteration 10 leaves you wanting more, and you can actually feel as though a full game is beginning to take shape.
As I said before, this is just one example of how you might add life to a game with this kind of gameplay and presentation style. There are infinitely many ways to make your experience come to life in the hands of your players, and it’s up to you to master that art.
The next time you play a game, stop and ask yourself why it feels satisfying. Don’t just think about how it looks, how it sounds, or how it plays. Think about the choices you have, the possible permutations of events there are, and the feedback you’re seeing and hearing as a result of your input. Think about how that feedback influences your choices, and try to understand why those decisions were made during development. The best way to learn about game design is to ask questions that you may never find the answer to.
It’s like searching
for the meaning of life: you will never find the answer, but your knowledge of
the world and of yourself will undoubtedly grow along the way.
Subscribe below and we’ll send you a weekly email summary of all new Game Development tutorials. Never miss out on learning about the next big thing.Update me weekly
Envato Tuts+ tutorials are translated into other languages by our community members—you can be involved too!Translate this post