There are numerous ways to implement an infinite runner style mechanism in Unity. In this Devblog I will show you how we do it in our game, AwesomeDillos and at the same time teach you how to do it – or at least give you ideas on how to do it – in your own game. Let’s begin!

What you will need

To get started, we need 2-5 sprites which will serve as the pieces of the level that we will be generating ad infinitum (of course, the more you have these modules the more diversity you will get in the level). We will need something to represent the player also, so use a sprite or a generic cube. If you don’t have any sprites of your own, you can download and use quality material from www.opengameart.org.

Basic idea

The concept here is that each of the level sprites will be made into a prefab and by constructing different kinds of prefabs from different kinds of sprites, it will create variation to the level. For example, one prefab could be a sprite of a hill, added with power-ups, collectables etc. and another could be a sprite of a trap with its corresponding collectables and such. So it’s sort of a modular approach. You construct different modules and generate them randomly or if you want with some predetermination and that creates the infinite map.

Let’s begin

First of all, create a new folder called “Resources” in your Assets folder. Here we will create another folder called “Prefabs”. Create 5 prefabs into this folder by clicking the right mouse button  Create  Prefab. Then add the sprites to the “Sprites” folder, add them to the scene and drag them to each individual prefab. Now your prefabs folder and your folder hierarchy should look like this:

You can of course name the individual prefabs anyway you want.

The LevelGenerator script

Let’s take a look at the LevelGenerator script that handles the creation of our level.

The script is pretty self-explanatory and we have commented all the important parts. What we basically do is we load all the prefabs into an array (levelPieces) and at appropriate times add parts from the array to the queue (piecesQueue) and also remove the parts that are obsolete (meaning the player has moved past them far enough so they can be deleted).

What keeps track of the parts in the actual scene is the activeParts list which we use delete the correct level pieces in the right order. It’s a pretty simple approach but it’s powerful enough so that we can add the variation to the level that we need. By using prefabs as modules for the map we can add all sorts of things to them and make the level seem different every time you play it.

Remember, you can add child objects to prefabs so the prefab can be more than just a sprite of the level; it can have collectables like power-ups and coins also. You can have predetermination instead of complete randomness in the level by for example constructing arrays with specific prefabs that make up a different sort of section that you want and then queue the whole array at some point of your own choosing.

Player movement

Here’s a small script for the automated player movement so you can see the mechanism in action:

Here’s how it should look when done right (the footage is not from actual gameplay, just the mechanic in action at its most basic state):

So that is basically the mechanism we use in our game, AwesomeDillos. We do use a separate system for the background generation and parallaxing but that’s a topic for another devlog in the near future! Stay tuned for a video version of this devlog where we will explain the mechanism in greater detail, perhaps there is something that you would still like to know more about.

Be sure to follow us on facebook and twitter!

-the Tuiske team

Our game project that we’ve been developing this past summer (while we’ve been one of the teams at Turku Boost Startup Journey), has progressed to alpha phase. Our core mechanics are now implemented but we will be updating them and we’re also gonna be adding lots of cool stuff in the very near future.
The game has 2 main mechanics that we will go into detail on how they were made: the drawing and the infinite runner mechanic. And because we use Unity as our game engine, these will also serve as Unity tutorials so as we show you the concept and implementation of these mechanics, you will get to learn how to use Unity and hopefully get some ideas on how to implement these sort of mechanics yourself. Learning is so cool, right?

The main objective in our game is to navigate the player as far as you can by drawing objects in to the game that help the main character progress through the levels. You also need to collect items and chili’s that boost your speed momentarily and rack up your score too. The key is to react quickly to the dangers in the environment – for example, there will be holes in the level that you don’t want the hero to drop into. So in this situation you would draw a bridge over the gap so that the hero can cross it.

We also have a new main character that our graphics designer Marianna provided for us. It’s an armadillo who wears these cool old timey pilot glasses that he needs when flying through the air at high speeds. Eye safety is important people! As is looking awesome of course.

So, if you’re interested in finding out how we make our game and also learning about all things Unity, follow us on Twitter and Facebook so you will updated the moment we release some new info. Stay tuned!