Welcome to the sixth part in our Endless Runner tutorial series! Our game is starting to shape up and feel more polished. After completing today's steps, it will be much more interactive and fun to play. We will add two more events that will create some exciting new challenges for the players. First, we'll add the ability for our hero to fire a small bolt to clear obstacles that come toward him. Keep in mind that the little "blueish" image is being fired from our monster. The images we're working with are not especially professional-looking since they are just for practice. After the monster has the ability to fire some bolts, we will also add events which will send obstacles coming back toward him. After that, we'll create two types of obstacles: the first is a spike wall that will sit on the ground and travel at the same speed as the ground, and the second is a ghost that will fly in from the upper right side of the screen toward the player.
So, let's get started! The first thing that we need to do is to make sure we have all of the assets in the right place. Download the file attached to this tutorial, and in the "new" folder you will find three new assets. You can also just right-click on the images and save them in the correct folder. The images should be named spikeBlock.png, ghost.png, and blast.png.
Open up your main.lua file that can be found in the "old" folder of the tutorial downloads. We will start by giving our players the ability to fire because we don't want to leave them defenseless as they are bombarded with new challenges! We can add this ability in three steps. The first will be instantiating 5 bolts and putting them in a group. Rather than creating and destroying objects every time we want to use them, we can be more efficient by preparing them and storing them off-screen until we need to use them. We are actually going to be doing the same thing for each of the three different images, so go ahead and add this code in between where we declare the variable speed and where we create our blocks.
--create ghosts and set their position to be off-screen for a = 1, 3, 1 do ghost = display.newImage("ghost.png") ghost.name = ("ghost" .. a) ghost.id = a ghost.x = 800 ghost.y = 600 ghost.speed = 0 --variable used to determine if they are in play or not ghost.isAlive = false --make the ghosts transparent and more... ghostlike! ghost.alpha = .5 ghosts:insert(ghost) end --create spikes for a = 1, 3, 1 do spike = display.newImage("spikeBlock.png") spike.name = ("spike" .. a) spike.id = a spike.x = 900 spike.y = 500 spike.isAlive = false spikes:insert(spike) end --create blasts for a=1, 5, 1 do blast = display.newImage("blast.png") blast.name = ("blast" .. a) blast.id = a blast.x = 800 blast.y = 500 blast.isAlive = false blasts:insert(blast) end
Notice that they all have some common features. We need to go through and name them in case we ever want to reference them individually. We give them an id, also giving us more future reference options. We give them their offscreen x and y coordinates (we stack similar images on top of each other). Another thing we give them all is the variable 'alive'. This is set to false by default as they will be sitting off the screen. Giving the sprites this variable will allow us to quickly check whether the sprite is in use or not. The only sprite that has anything different is the ghost sprite. For ghost sprites we'll add a speed variable so that we can have ghosts moving at random speeds. We'll also set the alpha of the ghosts to .5 so that they appear more, shall we say, ghostlike!
The next two things that we need to do are to create their respective display groups, then add those groups to the screen display group so that we will be able to see them in the game. Add these right beneath the other display groups' instantiation.
local ghosts = display.newGroup() local spikes = display.newGroup() local blasts = display.newGroup()
Next, go down to the section where we add everything to screen. Add those display groups in with the rest. I would make the new order look something like this:
--most of the order here does not matter as long as the backgrounds --are in back and the ghosts and monster are at the end screen:insert(backbackground) screen:insert(backgroundfar) screen:insert(backgroundnear1) screen:insert(backgroundnear2) screen:insert(blocks) screen:insert(spikes) screen:insert(blasts) screen:insert(ghosts) screen:insert(monster) screen:insert(collisionRect)
Once you have everything in there, it should look something like this if you were to run it in the iPhone 4 perspective:
After getting that in place, we'll add the function that updates all of the bolts that our monster shoots. Add the following function beneath the checkCollisions() function.
function updateBlasts() --for each blast that we instantiated check to see what it is doing for a = 1, blasts.numChildren, 1 do --if that blast is not in play we don't need to check anything else if(blasts[a].isAlive == true) then (blasts[a]):translate(5, 0) --if the blast has moved off of the screen, then kill it and return it to its original place if(blasts[a].x > 550) then blasts[a].x = 800 blasts[a].y = 500 blasts[a].isAlive = false end end --check for collisions between the blasts and the spikes for b = 1, spikes.numChildren, 1 do if(spikes[b].isAlive == true) then if(blasts[a].y - 25 > spikes[b].y - 120 and blasts[a].y + 25 < spikes[b].y + 120 and spikes[b].x - 40 < blasts[a].x + 25 and spikes[b].x + 40 > blasts[a].x - 25) then blasts[a].x = 800 blasts[a].y = 500 blasts[a].isAlive = false spikes[b].x = 900 spikes[b].y = 500 spikes[b].isAlive = false end end end --check for collisions between the blasts and the ghosts for b = 1, ghosts.numChildren, 1 do if(ghosts[b].isAlive == true) then if(blasts[a].y - 25 > ghosts[b].y - 120 and blasts[a].y + 25 < ghosts[b].y + 120 and ghosts[b].x - 40 < blasts[a].x + 25 and ghosts[b].x + 40 > blasts[a].x - 25) then blasts[a].x = 800 blasts[a].y = 500 blasts[a].isAlive = false ghosts[b].x = 800 ghosts[b].y = 600 ghosts[b].isAlive = false ghosts[b].speed = 0 end end end end end
The above function is going to have two main responsibilities. The first is to update the position of the blast and check to see if it collided with anything. You can see that when it collides with something, the way we destroy it is to simply move it off-screen and set isAlive to false. This will get the bolt ready to be used again. Something else that you might have noticed is that we only instantiate five bolts. So, what happens if all five bolts are already in play and the user tries to fire another blast? Nothing! With the way it is set up right now, the user is limited to only having five active blasts at one time. This is easy to change by instantiating more at the beginning of the game, but it shows you how to set limits to players. This is also a method we will use to make sure that 50 ghosts don't randomly generate all at once on the screen, instantly killing the player.
Next we need to go down to the touched function to give the player the ability to shoot. Change the touched function to match the following:
--the only difference in the touched function is now if you touch the --right side of the screen the monster will fire off a little blue bolt function touched( event ) if(event.phase == "began") then if(event.x < 241) then if(onGround) then monster.accel = monster.accel + 20 end else for a=1, blasts.numChildren, 1 do if(blasts[a].isAlive == false) then blasts[a].isAlive = true blasts[a].x = monster.x + 50 blasts[a].y = monster.y break end end end end end
Lastly, be sure to add updateBlasts() to the main update function and you should be ready to go. Give that a try and see the awesome power that our monster has now! After running it you should see something like this:
Now that the players can defend themselves, let's go ahead and give them some challenges. Both of these next events will be overcome by simply shooting them once. After they are in place, however, it will be easy for you to change them to suit your own project. We will start with the spiked wall.
The spiked wall will simply be placed on top of the current ground and move at the same constant speed as the ground around it. First thing to do is add the updateSpikes function. Right below the updateBlasts() function add the following code:
--check to see if the spikes are alive or not, if they are --then update them appropriately function updateSpikes() for a = 1, spikes.numChildren, 1 do if(spikes[a].isAlive == true) then (spikes[a]):translate(speed * -1, 0) if(spikes[a].x < -80) then spikes[a].x = 900 spikes[a].y = 500 spikes[a].isAlive = false end end end end
This will do the same thing as our updateBlast function. It will simply update the position of the spiked wall and check to see if it went off the screen (which it currently can't do because it would hit the player first). Just in case, though, we'll check to make sure. The last thing we need to do is make an event for it. In checkEvent() below the other checks add this:
--the more frequently you want events to happen then --greater you should make the checks if(check > 72 and check < 81) then inEvent = 12 eventRun = 1 end
We are going to actually add our wall in the updateBlocks() function. That way we are sure to have the current groundLevel. Right before you call checkEvent() insert the following:
--by setting up the spikes this way we are guaranteed to --only have 3 spikes out at most at a time. if(inEvent == 12) then for a=1, spikes.numChildren, 1 do if(spikes[a].isAlive == true) then --do nothing else spikes[a].isAlive = true spikes[a].y = groundLevel - 200 spikes[a].x = newX break end end end
The last thing to do in order to get this up and running is add the collision detection to see if our player ran into it or not. Put this right below the section in checkCollisions() where we check the collisions between the blocks and the monster.
--stop the game if the monster runs into a spike wall for a = 1, spikes.numChildren, 1 do if(spikes[a].isAlive == true) then if(collisionRect.y - 10> spikes[a].y - 170 and spikes[a].x - 40 < collisionRect.x and spikes[a].x + 40 > collisionRect.x) then --stop the monster speed = 0 end end end
Be sure to add updateSpikes() to the main update function again and give it a run! You should now have these spikes in your monster's path.
Give that a whirl and practice shooting them down. Remember to test to make sure the collisions are working correctly with the blasts. Also make sure that running into the walls actually kills the player. Once you have tested that and are ready for more, start putting the code in place for the ghost.
Putting the ghost in is pretty much identical to putting the wall in. The biggest difference between the two is that for the ghost we are going to randomize where it comes in at as well as how fast it travels. We'll also make the ghosts move up and down so that they are always moving to where the user is. Special details like that will make the obstacles feel entirely different to the user, even though they work in such a similar way.
Let's start again by adding the updateGhosts() function. While you're at it, go ahead and add updateGhosts() to the main update function as well.
--update the ghosts if they are alive function updateGhosts() for a = 1, ghosts.numChildren, 1 do if(ghosts[a].isAlive == true) then (ghosts[a]):translate(speed * -1, 0) if(ghosts[a].y > monster.y) then ghosts[a].y = ghosts[a].y - 1 end if(ghosts[a].y < monster.y) then ghosts[a].y = ghosts[a].y + 1 end if(ghosts[a].x < -80) then ghosts[a].x = 800 ghosts[a].y = 600 ghosts[a].speed = 0 ghosts[a].isAlive = false; end end end end
Next go back into the checkEvent() function and add this below the previous checks:
--ghost event if(check > 60 and check < 73) then inEvent = 13 eventRun = 1 end
This time instead of getting the ghosts moving from the updateBlocks function, we will do it in the runEvent() function. Add this below the other if statements:
--this will be a little bit different as we want this to really --make the game feel even more random. change where the ghosts --spawn and how fast they come at the monster. if(inEvent == 13) then for a=1, ghosts.numChildren, 1 do if(ghosts[a].isAlive == false) then ghosts[a].isAlive = true ghosts[a].x = 500 ghosts[a].y = math.random(-50, 400) ghosts[a].speed = math.random(2,4) break end end end
Once that is in there we need to check for collisions between the monster and the ghosts. Add this to checkCollions() right after we do the work for the spiked walls:
--make sure the player didn't get hit by a ghost! for a = 1, ghosts.numChildren, 1 do if(ghosts[a].isAlive == true) then if((( ((monster.y-ghosts[a].y))<70) and ((monster.y - ghosts[a].y) > -70)) and (ghosts[a].x - 40 < collisionRect.x and ghosts[a].x + 40 > collisionRect.x)) then --stop the monster speed = 0 end end end
You should now have everything in place, including the ghosts to dodge!
The game should now be a lot more fun and challenging for users. In the next tutorial we will add two more things that will make our game feel more complete: (1) a scoring system, and (2) monster death! We covered a lot in this tutorial, so if you have any questions, please sound off in the comments below. Thanks for reading!