Modern art using the GPU

Welcome to the final part of the “SteamLands” tutorial series, where we will complete the game!

In this tutorial, we are going to modify minor stuff to the game, add some power ups and add another enemy. We are also going to handle the main menu. I won’t be as detailed as in the earlier tutorials since you should know these things by now so congratulations!

This tutorial might seem very long – but fear not, there is a lot of source code listings and images. Anyways, hope you will learn a lot!

Download the project, source and assets of the complete game here.

I. Fixing the Intertia Tensor exception

Let’s start with fixing a few issues from the previous tutorials. I waited with fixing them because I didn’t want to give you evertything at once.

The first one is the issue that you propbably have notices – an exception saying there is an issue with some kind of inertia tension:

“Actor::updateMassFromShapes: Compute mesh inertia tensor failed for one of the actor’s mesh shapes! Please change mesh geometry or supply a tensor manually!”

The reason for this is that there is Mesh Colliders attached to all our Quads (except for the background, we removed it alread).

Go to the Players Texture Game Object and remove the Mesh Collider component:

Do the same for the Enemy prefab and the Laser prefab.

Play the game again and notice that the exceptions are gone!

II. Fixing the Enemy

First of all, the size of our enemy is a bit too small. The prefab spawns the enemy at the scale 1,1, but it should be 1.28, 0.93 to reflect the texture size. Change this in the prefab of the Enemy:

Also, change the shader of the enemys texture game object to the same we used for our player:

Then change the collision box for the enemy:

The EnemyHandler script was also changed so the enemies won’t spawn outside of the sidewalk, and how they are spawned (so it doesnt get insane).

III. Fixing the player

The players level list is essensial. Right now, the level up system is linear. We will change it so you will need more and more xp before leveling up for each level you get.

Change the level list builder code in the PlayerHandler to this:

void Start () {
    int currentXp = 0;
    int xpToIncrease = 50;

    for (int i = 0; i < 20; i++)
    {
        currentXp += xpToIncrease;
        levelList.Add(currentXp);
        xpToIncrease = (int)(xpToIncrease * 1.25);
    }

    playerHandler = this.GetComponent<PlayerHandler>();

}

The levels list now look like this:

This means that we must introduce more enemies as well!

IV. Adding more enemies

Let’s add a new enemy by duplicating the exsiting enemy and call it enemy2.

Let’s also give the enemy HP and the same hit effect that the player got. Open the EnemyHandler and add a new public variable that will keep track of the enemy HP:
public int Hp;

Change the routine that kills the enemy so it subracts the HP. If HP is less or equal zero, we destroy it:

void OnCollisionEnter(Collision collision)
{
    if (collision.rigidbody != null)
    {
        if (collision.rigidbody.name == “Player”)
        {
            Instantiate(explodePrefab, this.transform.position, Quaternion.identity);
            Instantiate(smokePrefab, this.transform.position, Quaternion.identity);
            Destroy(this.gameObject);
        }

        if (collision.rigidbody.tag == “Laser”)
        {
            Hp -= 1;
               
           Instantiate(smokePrefab, this.transform.position, Quaternion.identity);

            if (Hp <= 0)
            {
                isDead = true;
                Destroy(collision.gameObject);

                if (animationHandler != null)
                {
                    animationHandler.playAnimationSetNumber = 2;
                }
            }
        }
    }
}

On the Enemy2 prefab, change the Hp to 2:

(Notice that we don’t need to set the Hp if the enemy is just having one life. This is because our test for Hp is inside the collision function, so it won’t run before we hit it with a laser).

In the GameHandler script, add a new public variable that will contain the Enemy2 prefab:
public GameObject enemy2;

Perfect, now we need to spawn enemy2 randomly after turning level 2.

using UnityEngine;
using System.Collections;
public class GameHandler : MonoBehaviour
{
    public int level;

    public GameObject enemy;
    public GameObject enemy2;

    public GameObject player;

    public PlayerHandler playerHandler;

    public GUIText levelLabel;
    public GUIText xpLabel;

    float colorModifier = 1.0f;

    float spawnNewEnemyTimer = 2;

    // Use this for initialization
    void Start()
    {
        playerHandler = player.GetComponent<PlayerHandler>();
    }

    // Update is called once per frame
    void Update()
    {
        spawnNewEnemyTimer -= Time.deltaTime;
        if (spawnNewEnemyTimer <= 0)
        {
            spawnNewEnemyTimer = 5;

            int spawnNumberOfEnemies = 1 + (level/1);

            for (int i = 0; i < spawnNumberOfEnemies; i++)
            {
                GameObject enemyToSpawn;
                enemyToSpawn = enemy;

                if (level > 2)
                {
                    float rndEnemy = Random.Range(0.0f, 1.0f);
                    if (rndEnemy >= 0.5)
                    {
                        enemyToSpawn = enemy;
                    }
                    else
                    {
                        enemyToSpawn = enemy2;
                    }
                }

                float modifier = Random.Range(-1.0f, 1.0f) * 3;

                Instantiate(enemyToSpawn, new Vector3(player.transform.position.x + 20.0f + i * 3,
                       player.transform.position.y + modifier, 0.0f), Quaternion.identity);
            }

        }

        if (playerHandler != null)
        {
            level = playerHandler.Level;
            levelLabel.text = “Level ” + (level+1);

            int xpInLevel = playerHandler.Xp;
            if (level > 0)
            {
                xpInLevel = playerHandler.Xp – playerHandler.levelList[level – 1];
            }

            int xpForNextLevel = (playerHandler.levelList[level]);
            if(level > 0)
                xpForNextLevel = playerHandler.levelList[level] – playerHandler.levelList[level – 1];

            xpLabel.text = xpInLevel + “/” + xpForNextLevel;
        }
    }
}

Set the enemy2 variable in the editor:

Also, set the Texture vaiable in both Enemy and Enemy2 prefabs to their own Texture Game Object:

We also want to set the texture of the new Enemy2 prefab to another one. Add this texture to the Enemy Texture folder (can be found in this chapters assets folder):

Duplicate the enemy material, name it Enemy2Material and assign the new texture to it.

Drag it on the Enemy2Prefabs Texture Game Object, inside the Materials collection:

Now, change the size of the Enemy2Prefab main game object:

And the collision box:

V. Drawing our health bar

The next thing we want to do is to have a UI for the Hp our player got left.

Duplicate the LevelLabel and rename it to HpLabel, and set the following properties:

Now, modify the GameHandler script so we take this label and set it to our HP:

using UnityEngine;
using System.Collections;
public class GameHandler : MonoBehaviour
{
    public int level;

    public GameObject enemy;
    public GameObject enemy2;

    public GameObject player;

    public PlayerHandler playerHandler;

    public GUIText levelLabel;
    public GUIText xpLabel;
    public GUIText hpLabel;

    float colorModifier = 1.0f;

    float spawnNewEnemyTimer = 2;

    // Use this for initialization
    void Start()
    {
        playerHandler = player.GetComponent<PlayerHandler>();
    }

    // Update is called once per frame
    void Update()
    {
        spawnNewEnemyTimer -= Time.deltaTime;
        if (spawnNewEnemyTimer <= 0)
        {
            spawnNewEnemyTimer = 5;

            int spawnNumberOfEnemies = 1 + (level/2);

            for (int i = 0; i < spawnNumberOfEnemies; i++)
            {
                GameObject enemyToSpawn;
                enemyToSpawn = enemy;

                if (level > 2)
                {
                    float rndEnemy = Random.Range(0.0f, 1.0f);
                    if (rndEnemy > 0.5)
                    {
                        enemyToSpawn = enemy;
                    }
                    else
                    {
                        enemyToSpawn = enemy2;
                    }
                }

                float modifier = Random.Range(-1.0f, 1.0f) * 3;

                Instantiate(enemyToSpawn, new Vector3(player.transform.position.x + 20.0f + i * 3,
                       player.transform.position.y + modifier, 0.0f), Quaternion.identity);
            }

        }

        if (playerHandler != null)
        {
            level = playerHandler.Level;
            levelLabel.text = “Level ” + (level+1);

            int xpInLevel = playerHandler.Xp;
            if (level > 0)
            {
                xpInLevel = playerHandler.Xp – playerHandler.levelList[level – 1];
            }

            int xpForNextLevel = (playerHandler.levelList[level]);
            if(level > 0)
                xpForNextLevel = playerHandler.levelList[level] – playerHandler.levelList[level – 1];

            xpLabel.text = xpInLevel + “/” + xpForNextLevel;

           hpLabel.text = “[ “;
            for (int i = 0; i < playerHandler.HP; i++)
            {
                hpLabel.text += “|”;
            }
            hpLabel.text += “] “;

            if (playerHandler.HP <= 3)
                hpLabel.color = Color.red;
            else hpLabel.color = new Color(88.0f / 255.0f, 82.0f / 255.0f, 75.0f / 255.0f);
        }
    }
}

Remember to set the label in the Main Cameras properties:

This draws a string of characters (|) based on how much Hp you got left. Then this is set to a color based on how low your hp is.

VI. Adding power-ups

The next thing we want is a power-up that enables us to refill our Hp! Add a new GameObject to the scene and name it “HPPowerUp”.

Then create a new Material called HPPowerUp and add this texture to it (can also be found in the assets folder of this tutorial):

Set the texture to GUI:

Add a new Quad to the HPPowerUp Game Object and name it Texture. Then apply the new material to it. As for the Materials Shader, choose the same as we did for our player and enemy:

Set the size of the game object:

Add a new tag “PowerUp”:

And set it to our HPPowerUp:

Create a prefab out of it (in the prefrabs folder) and delete it from the scene:

Also, set the scale of the transform, remove the Mesh Renderer from the Texture of the powerup, as well as adding a RigidBody and a Box Collider to the HPPowerUp Game Object:

In the GameHandler, we are adding a new public variable that holds the powerup, and then create some logic to instanciate at random:

using UnityEngine;
using System.Collections;
public class GameHandler : MonoBehaviour
{
    public int level;

    public GameObject enemy;
    public GameObject enemy2;

    public GameObject player;

    public PlayerHandler playerHandler;

    public GUIText levelLabel;
    public GUIText xpLabel;
    public GUIText hpLabel;

    public GameObject hpPowerUp;

    float colorModifier = 1.0f;

    float spawnNewEnemyTimer = 2;

    // Use this for initialization
    void Start()
    {
        playerHandler = player.GetComponent<PlayerHandler>();
    }

    // Update is called once per frame
    void Update()
    {
        spawnNewEnemyTimer -= Time.deltaTime;
        if (spawnNewEnemyTimer <= 0)
        {
            spawnNewEnemyTimer = 5;

            int spawnNumberOfEnemies = 1 + (level/2);

            for (int i = 0; i < spawnNumberOfEnemies; i++)
            {
                GameObject enemyToSpawn;
                enemyToSpawn = enemy;

                if (level > 2)
                {
                    float rndEnemy = Random.Range(0.0f, 1.0f);
                    if (rndEnemy > 0.5)
                    {
                        enemyToSpawn = enemy;
                    }
                    else
                    {
                        enemyToSpawn = enemy2;
                    }
                }

                float modifier = Random.Range(-1.0f, 1.0f) * 3;

                Instantiate(enemyToSpawn, new Vector3(player.transform.position.x + 20.0f + i * 3,
                       player.transform.position.y + modifier, 0.0f), Quaternion.identity);
            }

            float rndPowerupHp = Random.Range(0.0f, 1.0f);
            if (rndPowerupHp < 0.1)
            {
                Instantiate(hpPowerUp, new Vector3(player.transform.position.x + 30.0f,
                       player.transform.position.y, 0.0f), Quaternion.identity);
            }
        }

        if (playerHandler != null)
        {
            level = playerHandler.Level;
            levelLabel.text = “Level ” + (level+1);

            int xpInLevel = playerHandler.Xp;
            if (level > 0)
            {
                xpInLevel = playerHandler.Xp – playerHandler.levelList[level – 1];
            }

            int xpForNextLevel = (playerHandler.levelList[level]);
            if(level > 0)
                xpForNextLevel = playerHandler.levelList[level] – playerHandler.levelList[level – 1];

            xpLabel.text = xpInLevel + “/” + xpForNextLevel;

            hpLabel.text = “[ “;
            for (int i = 0; i < playerHandler.HP; i++)
            {
                hpLabel.text += “|”;
            }
            hpLabel.text += ” ] “;
            if (playerHandler.HP <= 3)
                hpLabel.color = Color.red;
            else hpLabel.color = new Color(88.0f / 255.0f, 82.0f / 255.0f, 75.0f / 255.0f);
        }
    }
}

In the PlayerHandler script, we check for the collision of the powerup and then we destroy it and add Hp (cap at 10 hp).

if (collision.rigidbody.tag == “PowerUp”)
{
    Destroy(collision.gameObject);
    HP += 5;
    if (HP > 10)
        HP = 10;
}

What is the goal of the game? To get as much Xp and Levels as possible. When it’s game over, we will store the best level and score in the PlayerPrefs.

VII. Adding some scenery items

We can use the same technique as we did with the powerups (except we dont need collisions) to spawn buildings.

We add two new Materials, one for the tower and one for the factory:

(remember to set both textures to GUI)

And then we create a new GameObject with a Texture for each of these two buildings and assign the Materials to them, they way we have been doing in this tutorial.

We then add a new script to the scripts folder that is named GameObjectDestroyer.

This script will automatically destroy the game objects that are outside of the screen:

using UnityEngine;
using System.Collections;

public class GameObjectDestroyer : MonoBehaviour {
    GameObject player;

    // Use this for initialization
    void Start () {
        GameObject _p = GameObject.Find(“Player”);
        if (_p != null)
        {
            player = _p;
        }
    }
   
    // Update is called once per frame
    void Update () {
        if (player != null)
        {
            if (this.transform.position.x <= player.transform.position.x – 20.0f)
            {
                Destroy(this.gameObject);
            }
        }
    }
}

Then we add these as a reference in the GameHandler script and spawn them randomly, as we did with the HP Power Up:

float rndBuilding = Random.Range(0.0f, 1.0f);
if (rndPowerupHp < 0.5)
{
    GameObject whatBuilding = building1;

    float rndWhatBulding = Random.Range(0.0f, 1.0f);

    if (rndWhatBulding > 0.5)
    {
        whatBuilding = building1;
    }
    else
    {
        whatBuilding = building2;
    }

    Instantiate(whatBuilding, new Vector3(player.transform.position.x + 30.0f,
            0.0f, 0.0f), Quaternion.identity);
}

VIII. Creating the main menu and the Game Over scene

Find the two textures SteamLandsLogo and GameOver, and set them to GUI.

Next, create a new scene and save it as MainMenu.

Add a new GUI Texture and name it MainTexture:

Now, set the MainMenuLogo as the texture, and set the following properties:

Create a new script called MainMenu, add it to the Main Camera and modify it:

using UnityEngine;
using System.Collections;

public class MainMenu : MonoBehaviour {
    float startTimer = 2.0f;
    // Use this for initialization
    void Start () {
   
    }
   
    // Update is called once per frame
    void Update () {
        startTimer -= Time.deltaTime;

        if (startTimer <= 0)
        {
            if (Input.GetMouseButtonDown(0))
            {
                Application.LoadLevel(“Level”);
            }
        }
    }
}

The startTimer is there to make sure we aren’t loading the scene since “as many impatiently tap or click the mouse while loading”.

Also, click the Main Camera and set the background to:

Click File->Build Settings and then Add the current scene:

Now, load the Level scene and do the same thing to add it:

Add a new scene and save it as GameOver, do the same procedure as when creating the MainMenu scene – but now use the GameOver texture.

Add a GUI Text Game Object to the scene and name it “ScoreLabel”:

Create a GameOver script (instead of MainMenu) and add it to the Main Camera.

using UnityEngine;
using System.Collections;

public class GameOver : MonoBehaviour {
    float gameOverTimer = 5.0f;
    public GUIText scoreLabel;

    int score = 0;
    int level = 0;
    int highscore = 0;

    // Use this for initialization
    void Start () {
        score = PlayerPrefs.GetInt(“Score”, 0);
        level = PlayerPrefs.GetInt(“Level”, 1);
        highscore = PlayerPrefs.GetInt(“HighScore”, 0);

        if (score > highscore)
        {
            highscore = score;
        }

        scoreLabel.text = “Level ” + level + ” / Score: ” + score + “\nHigh score: ” + highscore;
    }
   
    // Update is called once per frame
    void Update () {
        gameOverTimer -= Time.deltaTime;
        if (gameOverTimer <= 0)
        {
            scoreLabel.text = “Tap to restart”;
            if(Input.GetMouseButtonDown(0))
            {
                Application.LoadLevel(“MainMenu”);
            }
        }
    }
}

The last thing we need to do is to check in the PlayerHandler that it’s game over. If it’s game over, set the dead animation, store the score and go to the GameOver scene:

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class PlayerHandler : MonoBehaviour {
    float speed = 4.0f;
    public GameObject laserPrefab;
    public GameObject textureObject;

    float shootTimer = 0.0f;
    float setShootTimerTo = 0.5f;

    public int Xp = 0;
    public int Level = 0;

    public List<int> levelList = new List<int>();
    PlayerHandler playerHandler;

    public int HP;
    float colorModifier = 1.0f;

    bool isGameOver = false;
    float gameOverTimer = 3.0f;

    AnimationHandler animationHandler;

    void OnCollisionEnter(Collision collision)
    {
        if (collision.rigidbody != null)
        {
            if (collision.rigidbody.tag == “Enemy”)
            {
                HP -= 1;
                colorModifier = 0.0f;
            }

            if (collision.rigidbody.tag == “PowerUp”)
            {
                Destroy(collision.gameObject);
                HP += 5;
                if (HP > 10)
                    HP = 10;
            }
        }
    }

    // Use this for initialization
    void Start () {
        int currentXp = 0;
        int xpToIncrease = 50;

        for (int i = 0; i < 20; i++)
        {
            currentXp += xpToIncrease;
            levelList.Add(currentXp);
            xpToIncrease = (int)(xpToIncrease * 1.25);
        }

        playerHandler = this.GetComponent<PlayerHandler>();
        animationHandler = this.GetComponent<AnimationHandler>();

    }
   
    // Update is called once per frame
    void Update () {
        if (HP <= 0)
        {
            isGameOver = true;
            animationHandler.playAnimationSetNumber = 2;
            gameOverTimer -= Time.deltaTime;

            if (gameOverTimer <= 0.0f)
            {
                PlayerPrefs.SetInt(“Score”, Xp);
                PlayerPrefs.SetInt(“Level”, Level);

                Application.LoadLevel(“GameOver”);
            }
        }

        if (!isGameOver)
        {
            Vector3 movePlayerVector = Vector3.right;
            shootTimer -= Time.deltaTime;

            textureObject.gameObject.renderer.material.color = new Color(1.0f, colorModifier, colorModifier);

            if (colorModifier < 1.0f)
                colorModifier += Time.deltaTime;

            if (Input.GetMouseButton(0))
            {
                Vector3 touchWorldPoint = Camera.main.ScreenToWorldPoint(
                    new Vector3(Input.mousePosition.x,
                                Input.mousePosition.y,
                                10.0f));

                if (touchWorldPoint.x < this.transform.position.x + 5.0f)
                {
                    if (touchWorldPoint.y > this.transform.position.y)
                    {
                        movePlayerVector.y = 1.0f;
                    }
                    else movePlayerVector.y = -1.0f;
                }
                else
                {
                    if (shootTimer <= 0)
                    {
                        Vector3 shootPos = this.transform.position;
                        shootPos.x += 2;
                        Instantiate(laserPrefab, shootPos, Quaternion.identity);
                        shootTimer = setShootTimerTo;
                    }
                }
            }

            this.transform.position += movePlayerVector * Time.deltaTime * speed;

            if (transform.position.y > -2.0)
            {
                transform.position = new Vector3(transform.position.x,
                                                -2.0f,
                                                transform.position.z);
            }

            if (transform.position.y < -5.5)
            {
                transform.position = new Vector3(transform.position.x,
                                                -5.5f,
                                                transform.position.z);
            }

            if (playerHandler.Xp >= levelList[Level])
            {
                Level++;
            }
        }
    }
}

This script is now disabling player input if game over, and then start counting for a few seconds so the player can understand he died and then we store the scores and redirect to to game over scene.

Be sure to add the GameOver scene too:

Additional stuff to do with this game:
You can also add a lable the show the Xp (Score) the player have revieved:

IX. Fun stuff to add – and is added in this projects tutorial solutiuon

This is a few minor things you can add to your game – it’s easy to implement and you should be capable to do it. Are you ready for some excerises?

And you could add more enemies and change how the levels affects spawing new stuff.

Also, refactoring of the Game Logic and code would be a good ide – I wrote it as simple as possible so it would be easier to understand the conecpts. You should put more stuff in functions and follow good programming practices and arcitecture.

You can change how much the potion gives you in Hp, 5 is a lot.

Also, when you crash in to another player – some times you

X. Publishing your game

Follow tutorial 3 and/or 4 to publish your game to Windows Store or Windows Phone Store. Do it now, and grab the potential of a new and growing market!

Good luck with your game development!

XI. Conclusion

This concludes the “SteamLands” tutorial. The next tutorial in this series will cover how you can write plugins to add the functionality of InApp purchases and programming the Live Tile!

Download the project, source and assets of the complete game here.

This tutorial will continue from the previous tutorial in this series.

Today we are going to add explosions, level ups and a UI.

Download the source and assets here.

I. Creating explosions

When a player dies, we want to make it dead, and make it explode!

First of all, we will make the movement stop and play the death animation. And then after one second, we will make it explode.

To do this, we need to edit the EnemyHandler script. What we will do is to add two prefabs that represent the explosion and smoke, then a boolean that indicates of the enemy is dead or not, and then a timer that will be set and counted after it is dead – resulting in an explosion after 0.5 seconds.

To change the animation that our enemy is playing, we need a reference to the AnimationHandler component of the current player. The can be found using GetComponent – it returns a component attached to the current Game Object.

Then, when the enemy is hit, we set the animation to dead, and then set the boolean isDead to true.

When this is true, we will start spawning the smokePrefab, and start the timer.

After 0.5 seconds, the timer is over and the enemy is dead + spawning an explosion.

Also, if the enemy hits the player, it will explode instantly. We also stop the enemy movement when the dead animation is playing.

Here is the code, try to see if you can understand it – it should not be anything new (except for GetComponent), just new ways to combine our rules to make our logic the way we want

using UnityEngine;
using System.Collections;

public class EnemyHandler : MonoBehaviour
{
    float speed = 4.0f;
    GameObject player;

    public GameObject explodePrefab;
    public GameObject smokePrefab;
    bool isDead = false;
    float isDeadTimer = 0.5f;

    AnimationHandler animationHandler;

    void OnCollisionEnter(Collision collision)
    {
        if (collision.rigidbody != null)
        {
            if (collision.rigidbody.name == “Player”)
            {
                Instantiate(explodePrefab, this.transform.position, Quaternion.identity);
                Instantiate(smokePrefab, this.transform.position, Quaternion.identity);
                Destroy(this.gameObject);
            }

            if (collision.rigidbody.tag == “Laser”)
            {
                isDead = true;
                Instantiate(smokePrefab, this.transform.position, Quaternion.identity);

                Destroy(collision.gameObject);

                if (animationHandler != null)
                {
                    animationHandler.playAnimationSetNumber = 0;
                }
            }
        }
    }
    // Use this for initialization
    void Start()
    {
        GameObject _p = GameObject.Find(“Player”);
        if (_p != null)
        {
            player = _p;
        }

        animationHandler = this.GetComponent<AnimationHandler>();
       
    }

    // Update is called once per frame
    void Update()
    {
        if (isDead)
        {
            isDeadTimer -= Time.deltaTime;
        }

       if (!isDead)
        {
            Vector3 moveVector = Vector3.left;
            transform.position += moveVector * speed * Time.deltaTime;
        }

        if (player != null)
        {
            if (this.transform.position.x <= player.transform.position.x – 10.0f)
            {
                Destroy(this.gameObject);
            }
        }

       if (isDeadTimer <= 0.0f)
        {
            Instantiate(explodePrefab, this.transform.position, Quaternion.identity);
            Destroy(this.gameObject);
           
        }
    }
}

Ok! Try to play the gama again now, and it suddenly feels much better – more action!

II. Adding hitpoints to the player

When we hit a player, it will explode – but we also want this to reduce the current health the player is having.

Open the PlayerHandler script and make the following modifications:

using UnityEngine;
using System.Collections;

public class PlayerHandler : MonoBehaviour {
    float speed = 4.0f;
    public GameObject laserPrefab;

    float shootTimer = 0.0f;
    float setShootTimerTo = 0.5f;

    public int HP;

    void OnCollisionEnter(Collision collision)
    {
        if (collision.rigidbody != null)
        {
            if (collision.rigidbody.tag == “Enemy”)
            {
                HP -= 1;
            }
        }
    }

    // Use this for initialization
    void Start () {
   
    }
   
    // Update is called once per frame
    void Update () {
        Vector3 movePlayerVector = Vector3.right;
        shootTimer -= Time.deltaTime;

        if (Input.GetMouseButton(0))
        {
            Vector3 touchWorldPoint = Camera.main.ScreenToWorldPoint(
                new Vector3(Input.mousePosition.x,
                            Input.mousePosition.y,
                            10.0f));

            if (touchWorldPoint.x < this.transform.position.x + 5.0f)
            {
                if (touchWorldPoint.y > this.transform.position.y)
                {
                    movePlayerVector.y = 1.0f;
                }
                else movePlayerVector.y = -1.0f;
            }
            else
            {
                if (shootTimer <= 0)
                {
                    Vector3 shootPos = this.transform.position;
                    shootPos.x += 2;
                    Instantiate(laserPrefab, shootPos, Quaternion.identity);
                    shootTimer = setShootTimerTo;
                }
            }
        }

        this.transform.position += movePlayerVector * Time.deltaTime * speed;

        if (transform.position.y > -2.0)
        {
            transform.position = new Vector3(transform.position.x,
                                            -2.0f,
                                            transform.position.z);
        }

        if (transform.position.y < -5.5)
        {
            transform.position = new Vector3(transform.position.x,
                                            -5.5f,
                                            transform.position.z);
        }
    }
}

Now, click the Player game object in the scene hierarchy and set the HP property to 10.

Press play and click the Player Game Object in the scene hierarchy. Take a look at the HP property and see that it will be reduced when we hit an enemy.

The last thing (for now) that we will do on the player is to show that we took damage when an enemy hits us. Then the enemy hits us, we set the color of our material to red, and then slowly fade back to white (white = original colors in the texture).

Modify the PlayerHandler script with the following changes:

using UnityEngine;
using System.Collections;

public class PlayerHandler : MonoBehaviour {
    float speed = 4.0f;
    public GameObject laserPrefab;
    public GameObject textureObject;

    float shootTimer = 0.0f;
    float setShootTimerTo = 0.5f;

    public int HP;
    float colorModifier = 1.0f;

    void OnCollisionEnter(Collision collision)
    {
        if (collision.rigidbody != null)
        {
            if (collision.rigidbody.tag == “Enemy”)
            {
                HP -= 1;
                colorModifier = 0.0f;
            }
        }
    }

    // Use this for initialization
    void Start () {
    }
   
    // Update is called once per frame
    void Update () {
        Vector3 movePlayerVector = Vector3.right;
        shootTimer -= Time.deltaTime;

        textureObject.gameObject.renderer.material.color = new Color(1.0f, colorModifier, colorModifier);

        if(colorModifier < 1.0f)
            colorModifier += Time.deltaTime;

        if (Input.GetMouseButton(0))
        {
            Vector3 touchWorldPoint = Camera.main.ScreenToWorldPoint(
                new Vector3(Input.mousePosition.x,
                            Input.mousePosition.y,
                            10.0f));

            if (touchWorldPoint.x < this.transform.position.x + 5.0f)
            {
                if (touchWorldPoint.y > this.transform.position.y)
                {
                    movePlayerVector.y = 1.0f;
                }
                else movePlayerVector.y = -1.0f;
            }
            else
            {
                if (shootTimer <= 0)
                {
                    Vector3 shootPos = this.transform.position;
                    shootPos.x += 2;
                    Instantiate(laserPrefab, shootPos, Quaternion.identity);
                    shootTimer = setShootTimerTo;
                }
            }
        }

        this.transform.position += movePlayerVector * Time.deltaTime * speed;

        if (transform.position.y > -2.0)
        {
            transform.position = new Vector3(transform.position.x,
                                            -2.0f,
                                            transform.position.z);
        }

        if (transform.position.y < -5.5)
        {
            transform.position = new Vector3(transform.position.x,
                                            -5.5f,
                                            transform.position.z);
        }
    }
}

As you can see, we also grabed the Texture component in a public variable, so this needs to be set.

Set the Texture Object of the Player to the Texture Game Object inside the player:

Also, click on the Texture of the Player game object and change the shader to:

This is because we want to be able to change the color of the material and see it in the texture in-game.

Now, the code works like this. We set the modifier to 0.0f, and whenever this is not 1.0f, we increase it so it becomes 1.0f (white). Then we set the color using this. When hit, the value of the modifier is 0.0f, thus the color of the material is 1,0,0 (red). Then we slowly increase the zeroes untill its 1,1,1 (white) again.

Press play now and let an enemy hit you. You can see that you also turn red and fade back to the normal color.

III. Giving the player Xp

When we kill an enemy, we want to reward the player with experience points, that will be used to level up (and increase how hard the game is).

Still in the PlayerHandler script, we create a new integer that is our current xp and another one that keeps track of the players level (the other level that is in the game handler is the current game level we are playing (how frequent and how enemies should spawn):

using UnityEngine;
using System.Collections;

public class PlayerHandler : MonoBehaviour {
    float speed = 4.0f;
    public GameObject laserPrefab;
    public GameObject textureObject;

    float shootTimer = 0.0f;
    float setShootTimerTo = 0.5f;

    public int Xp = 0;
    public int Level = 0;

    public int HP;
    float colorModifier = 1.0f;

    void OnCollisionEnter(Collision collision)
    {
        if (collision.rigidbody != null)
        {
            if (collision.rigidbody.tag == “Enemy”)
            {
                HP -= 1;
                colorModifier = 0.0f;
            }
        }
    }

    // Use this for initialization
    void Start () {
    }
   
    // Update is called once per frame
    void Update () {
        Vector3 movePlayerVector = Vector3.right;
        shootTimer -= Time.deltaTime;

        textureObject.gameObject.renderer.material.color = new Color(1.0f, colorModifier, colorModifier);

        if(colorModifier < 1.0f)
            colorModifier += Time.deltaTime;

        if (Input.GetMouseButton(0))
        {
            Vector3 touchWorldPoint = Camera.main.ScreenToWorldPoint(
                new Vector3(Input.mousePosition.x,
                            Input.mousePosition.y,
                            10.0f));

            if (touchWorldPoint.x < this.transform.position.x + 5.0f)
            {
                if (touchWorldPoint.y > this.transform.position.y)
                {
                    movePlayerVector.y = 1.0f;
                }
                else movePlayerVector.y = -1.0f;
            }
            else
            {
                if (shootTimer <= 0)
                {
                    Vector3 shootPos = this.transform.position;
                    shootPos.x += 2;
                    Instantiate(laserPrefab, shootPos, Quaternion.identity);
                    shootTimer = setShootTimerTo;
                }
            }
        }

        this.transform.position += movePlayerVector * Time.deltaTime * speed;

        if (transform.position.y > -2.0)
        {
            transform.position = new Vector3(transform.position.x,
                                            -2.0f,
                                            transform.position.z);
        }

        if (transform.position.y < -5.5)
        {
            transform.position = new Vector3(transform.position.x,
                                            -5.5f,
                                            transform.position.z);
        }
    }
}

Then in the Enemy script, if we kill the enemy, we add Xp to the player based on how difficlt the enemy is. Open the EnemyHandler script and do the following changes:

using UnityEngine;
using System.Collections;

public class EnemyHandler : MonoBehaviour
{
    float speed = 4.0f;
    GameObject player;

    public GameObject explodePrefab;
    public GameObject smokePrefab;
    bool isDead = false;
    float isDeadTimer = 0.5f;
    public int enemyDifficulty;

    AnimationHandler animationHandler;
    PlayerHandler playerHandler;

    void OnCollisionEnter(Collision collision)
    {
        if (collision.rigidbody != null)
        {
            if (collision.rigidbody.name == “Player”)
            {
                Instantiate(explodePrefab, this.transform.position, Quaternion.identity);
                Instantiate(smokePrefab, this.transform.position, Quaternion.identity);
                Destroy(this.gameObject);
            }

            if (collision.rigidbody.tag == “Laser”)
            {
                isDead = true;
                Instantiate(smokePrefab, this.transform.position, Quaternion.identity);

                Destroy(collision.gameObject);

                if (animationHandler != null)
                {
                    animationHandler.playAnimationSetNumber = 0;
                }
            }
        }
    }
    // Use this for initialization
    void Start()
    {
        GameObject _p = GameObject.Find(“Player”);
        if (_p != null)
        {
            player = _p;

            playerHandler = player.GetComponent<PlayerHandler>();
        }

        animationHandler = this.GetComponent<AnimationHandler>();
       
    }

    // Update is called once per frame
    void Update()
    {
        if (isDead)
        {
            isDeadTimer -= Time.deltaTime;
        }

        if (!isDead)
        {
            Vector3 moveVector = Vector3.left;
            transform.position += moveVector * speed * Time.deltaTime;
        }

        if (player != null)
        {
            if (this.transform.position.x <= player.transform.position.x – 10.0f)
            {
                Destroy(this.gameObject);
            }
        }

        if (isDeadTimer <= 0.0f)
        {
            Instantiate(explodePrefab, this.transform.position, Quaternion.identity);
            Destroy(this.gameObject);
            playerHandler.Xp += enemyDifficulty * 10;
        }
    }
}

What we are doing here is to create a new public variable for the enemy, the difficulty in Level. Then in the Start() function, we find the PlayerHandler component of the player object and if the enemy is dead, we add 10 x the level of our enemy (difficulty) to the players Xp.

Go to the enemy prefab and set the difficulty to 1:

Play the game and make sure you are getting Xp!

IV. Increasing the players level

The next thing we want to do is to increase the players level based on the Xp he gets.

We do this in the PlayerHandler script. What we will do is to create a lookup list that contains what XP is needed to become a given level.

Then, we set the players level to this level based on the Xp.

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class PlayerHandler : MonoBehaviour {
    float speed = 4.0f;
    public GameObject laserPrefab;
    public GameObject textureObject;

    float shootTimer = 0.0f;
    float setShootTimerTo = 0.5f;

    public int Xp = 0;
    public int Level = 0;

    List<int> levelList = new List<int>();

    public int HP;
    float colorModifier = 1.0f;

    void OnCollisionEnter(Collision collision)
    {
        if (collision.rigidbody != null)
        {
            if (collision.rigidbody.tag == “Enemy”)
            {
                HP -= 1;
                colorModifier = 0.0f;
            }
        }
    }

    // Use this for initialization
    void Start () {
        for (int i = 0; i < 20; i++)
        {
            levelList.Add((int)(50 + (i * 50) + (i * 50 * 0.25)));
        }

    }
   
    // Update is called once per frame
    void Update () {
        Vector3 movePlayerVector = Vector3.right;
        shootTimer -= Time.deltaTime;

        textureObject.gameObject.renderer.material.color = new Color(1.0f, colorModifier, colorModifier);

        if(colorModifier < 1.0f)
            colorModifier += Time.deltaTime;

        if (Input.GetMouseButton(0))
        {
            Vector3 touchWorldPoint = Camera.main.ScreenToWorldPoint(
                new Vector3(Input.mousePosition.x,
                            Input.mousePosition.y,
                            10.0f));

            if (touchWorldPoint.x < this.transform.position.x + 5.0f)
            {
                if (touchWorldPoint.y > this.transform.position.y)
                {
                    movePlayerVector.y = 1.0f;
                }
                else movePlayerVector.y = -1.0f;
            }
            else
            {
                if (shootTimer <= 0)
                {
                    Vector3 shootPos = this.transform.position;
                    shootPos.x += 2;
                    Instantiate(laserPrefab, shootPos, Quaternion.identity);
                    shootTimer = setShootTimerTo;
                }
            }
        }

        this.transform.position += movePlayerVector * Time.deltaTime * speed;

        if (transform.position.y > -2.0)
        {
            transform.position = new Vector3(transform.position.x,
                                            -2.0f,
                                            transform.position.z);
        }

        if (transform.position.y < -5.5)
        {
            transform.position = new Vector3(transform.position.x,
                                            -5.5f,
                                            transform.position.z);
        }

        if (Xp >= levelList[Level])
        {
             Level++;
        }
    }
}

In the GameHandler script, we want to make the game harder and harder over time. There are multiple design choises on how this can be done. You can make the level of the game just as hard as the level you are at, or you can make the game harder and harder over time and then it’s up to who you take out and what you do that you can keep up with how hard the game is.

We are going for the first, we are making the game harder and harder based on what level the player currently is.

In the GameHandler, we create a reference to the PlayerHandler, and then set the level integer of the game to equal the level of the player:

using UnityEngine;
using System.Collections;
public class GameHandler : MonoBehaviour
{
    public int level;

    public GameObject enemy;
    public GameObject player;

    public PlayerHandler playerHandler;

    float spawnNewEnemyTimer = 10;

    // Use this for initialization
    void Start()
    {
        playerHandler = player.GetComponent<PlayerHandler>();
    }

    // Update is called once per frame
    void Update()
    {
        spawnNewEnemyTimer -= Time.deltaTime;
        if (spawnNewEnemyTimer <= 0)
        {
            spawnNewEnemyTimer = 5 – (level * 0.25f);
            if (spawnNewEnemyTimer < 0.5f)
                spawnNewEnemyTimer = 0.5f;

            Instantiate(enemy, new Vector3(player.transform.position.x + 100.0f,
                    player.transform.position.y, 0.0f), Quaternion.identity);
        }

        if (playerHandler != null)
        {
            level = playerHandler.Level;
        }
    }
}

Cool! We now set the game level to reflect the players level.

Now, let’s make the game a bit harder as well (and not just increaseing the frequence of how often the player is spawned).

If you are Level 2 and above, we want to spawn 2 enemies instead of just one.

Modify the GameHandler additionally:

using UnityEngine;
using System.Collections;
public class GameHandler : MonoBehaviour
{
    public int level;

    public GameObject enemy;
    public GameObject player;

    public PlayerHandler playerHandler;

    float spawnNewEnemyTimer = 10;

    // Use this for initialization
    void Start()
    {
        playerHandler = player.GetComponent<PlayerHandler>();
    }

    // Update is called once per frame
    void Update()
    {
        spawnNewEnemyTimer -= Time.deltaTime;
        if (spawnNewEnemyTimer <= 0)
        {
            spawnNewEnemyTimer = 5 – (level * 0.25f);
            if (spawnNewEnemyTimer < 0.5f)
                spawnNewEnemyTimer = 0.5f;

            int spawnNumberOfEnemies = 1 + (level/3);
            for (int i = 0; i < spawnNumberOfEnemies; i++)
            {
                float modifier = Random.Range(0.0f, 1.0f);
                Instantiate(enemy, new Vector3(player.transform.position.x + 100.0f + i*10,
                       player.transform.position.y + modifier, 0.0f), Quaternion.identity);
            }

        }

        if (playerHandler != null)
        {
            level = playerHandler.Level;
        }
    }
}

The logic here is that we are spawning a given number of enemies based on what level we are. If we are level 1 and 2, we spawn 1 enemy. And then every thirst level from there spawns an additional enemy.

If you play the game for a while now, you can see this change in the game.

V. Adding the User Interface

We do the same as in tutorial 4. Add a new and empty game object to the scene and name it GUI:

Then add a GUITexture Game Object to it, and name it PlayerInfoTexture:

Then, click the UI Texture in the Textures folder (can be found in this projects assets folder) and change it to GUI:

Click Apply to save the changes. Then drag this texture on the GUI Texture we just added to the GUI Game Object and set the properties to the following:

Next, we want to add a text that shows our level and the Xp that we got left untill we get to a new level.

Add a new GUI Text game object to the scene and name it “LevelLabel”:

Set the properties to the following:

Duplicate the LevelLabel and rename it to XpLabel:

And modify the properties to the following:

Cool! We got our simple UI working! The last thing we need to do is to set the labels from our GameHandler script.

First, we need to make the levelList in the PlayerHandler public. Modify the script so it looks like this (one line):

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class PlayerHandler : MonoBehaviour {
    float speed = 4.0f;
    public GameObject laserPrefab;
    public GameObject textureObject;

    float shootTimer = 0.0f;
    float setShootTimerTo = 0.5f;

    public int Xp = 0;
    public int Level = 0;

    public List<int> levelList = new List<int>();
    PlayerHandler playerHandler;

    public int HP;
    float colorModifier = 1.0f;

    void OnCollisionEnter(Collision collision)
    {
        if (collision.rigidbody != null)
        {
            if (collision.rigidbody.tag == “Enemy”)
            {
                HP -= 1;
                colorModifier = 0.0f;
            }
        }
    }

    // Use this for initialization
    void Start () {
        for (int i = 0; i < 20; i++)
        {
            levelList.Add((int)(50 + (i * 50) + (i * 50 * 0.25)));
        }
        playerHandler = this.GetComponent<PlayerHandler>();

    }
   
    // Update is called once per frame
    void Update () {
        Vector3 movePlayerVector = Vector3.right;
        shootTimer -= Time.deltaTime;

        textureObject.gameObject.renderer.material.color = new Color(1.0f, colorModifier, colorModifier);

        if(colorModifier < 1.0f)
            colorModifier += Time.deltaTime;

        if (Input.GetMouseButton(0))
        {
            Vector3 touchWorldPoint = Camera.main.ScreenToWorldPoint(
                new Vector3(Input.mousePosition.x,
                            Input.mousePosition.y,
                            10.0f));

            if (touchWorldPoint.x < this.transform.position.x + 5.0f)
            {
                if (touchWorldPoint.y > this.transform.position.y)
                {
                    movePlayerVector.y = 1.0f;
                }
                else movePlayerVector.y = -1.0f;
            }
            else
            {
                if (shootTimer <= 0)
                {
                    Vector3 shootPos = this.transform.position;
                    shootPos.x += 2;
                    Instantiate(laserPrefab, shootPos, Quaternion.identity);
                    shootTimer = setShootTimerTo;
                }
            }
        }

        this.transform.position += movePlayerVector * Time.deltaTime * speed;

        if (transform.position.y > -2.0)
        {
            transform.position = new Vector3(transform.position.x,
                                            -2.0f,
                                            transform.position.z);
        }

        if (transform.position.y < -5.5)
        {
            transform.position = new Vector3(transform.position.x,
                                            -5.5f,
                                            transform.position.z);
        }

        if (playerHandler.Xp >= levelList[Level])
        {
            Level++;
        }
    }
}

Then save and open the GameHandler script. Edit the script and make the following modifications:

using UnityEngine;
using System.Collections;
public class GameHandler : MonoBehaviour
{
    public int level;

    public GameObject enemy;
    public GameObject player;

    public PlayerHandler playerHandler;

    public GUIText levelLabel;
    public GUIText xpLabel;

    float spawnNewEnemyTimer = 10;

    // Use this for initialization
    void Start()
    {
        playerHandler = player.GetComponent<PlayerHandler>();
    }

    // Update is called once per frame
    void Update()
    {
        spawnNewEnemyTimer -= Time.deltaTime;
        if (spawnNewEnemyTimer <= 0)
        {
            spawnNewEnemyTimer = 5 – (level * 0.25f);
            if (spawnNewEnemyTimer < 0.5f)
                spawnNewEnemyTimer = 0.5f;

            int spawnNumberOfEnemies = 1 + (level/3);
            for (int i = 0; i < spawnNumberOfEnemies; i++)
            {
                float modifier = Random.Range(0.0f, 1.0f);
                Instantiate(enemy, new Vector3(player.transform.position.x + 100.0f + i*10,
                       player.transform.position.y + modifier, 0.0f), Quaternion.identity);
            }
        }

        if (playerHandler != null)
        {
            level = playerHandler.Level;
            levelLabel.text = “Level ” + (level+1);

            int xpInLevel = playerHandler.Xp;
            if (level > 0)
            {
                xpInLevel = playerHandler.Xp – playerHandler.levelList[level – 1];
            }

            int xpForNextLevel = (playerHandler.levelList[level]);
            if(level > 0)
                xpForNextLevel = playerHandler.levelList[level] – playerHandler.levelList[level – 1];

            xpLabel.text = xpInLevel + “/” + xpForNextLevel;
        }
    }
}

This script simply calculates how much Xp is needed for the current level, how much the player got and then renders it in the xp label. The level label is also updated with the current level.

Set the referneces to the labels on the Main Camera like this:

Press play to see our game in action!

The game is now playable and pretty much awesome! You can play, kill stuff, see the explosions and the levels going up!

VI. Fixing the bad performance

There is ONE last thing we need to do in this tutorial.. as you keep playing, you can feel that the game starts lagging after a while. This is because the particles that renders our smoke keeps staying alive forever, resulting in thousands of particles being rendered in the scene.

We do this by adding a cutof script that comes with the standard assets folder.

First, find the Fluffy Smoke particle engine and click it to view the properties:

Find the TimedObjectDestructor script in the Legacy Particles script folder:

And drag it on the to the components area of the properties (its not very big):

(You release it when you see the mouse pointer turn in to something that looks like you can add stuff there)

Set the properties of the component to the following:

This means that the smoke system will automatically be destroyed after 5.0 seconds.

Give it a try, the performance of the game is much better!

Now – the game is getting impossible and even more laggy after a while so the next tutorial is all about finetuning, doing some balancing, spawning another type of enemy and picking up power ups and adding the UI for player health. We will also create the main menu, game over scene and publish it to the store.

Download the source and assets here.

Continuing from Part 2 of the more advanced game tutorial, we will add enemies and the possibility to shoot them with our laser!

You can download the project, source and game assets here.

I. Adding the enemy GameObject

The enemy GameObject will be built up the same as our Player – a main game object, a texture and a script to handle it. Go ahead and create a new empty game object, this will function as the main enemy game object:

Give it the name “Enemy”:

Set the position to 0,0,0:

Now we need to give the enemy a look, a texture. Create a new Quad game object:

Give it the name “Texture”:

Set the transform position to 0,0,0:

Put it inside the enemy game object:

Now, we need to create a look for our enemy. We start by creating a new material, assign our texture to it and add it to our enemy texture:
a) Add the Material and name it EnemyMaterial:

b) Give it the Enemy texture:

c) Set the shader to be Unlit/Transparent:

d) Assign it to the texture game object inside the enemy:

Now, we need to add animations to the enemy. We do this by using the same script we created in the previous tutorial.

Go to the Scripts folder and drag the AnimationHandler script to the enemy game object:
a) Find the AnimationHandler

b) Assign it to the enemy game object:

c) Set the Animation Set to 1 and drag the Texture Game Object inside the Enemy to the Texture To Animate property:

II. Scripting the enemy

The next thing we want to do is to script how the enemy behaves, and how it should spawn. We want it to spawn far out on the left side of our screen and move towards us.

Go ahead and create a new script in the Scripts folder, and name it EnemyHandler:

Assign it to the Enemy GameObject:

You can see that it’s now a component of the game object:

Edit the script in Visual Studio:

using UnityEngine;
using System.Collections;

public class EnemyHandler : MonoBehaviour {
    float speed = 4.0f;

    // Use this for initialization
    void Start () {
   
    }
   
    // Update is called once per frame
    void Update () {
        Vector3 moveVector = new Vector3(-speed, 0.0f, 0.0f);
        transform.position += moveVector * Time.deltaTime;
    }
}

The scripts contains a variable called speed that will be used to control the speed of our enemy. Then we use this to move it towards us (negative A-axis). Shouldn’t be anything new here

What’s mission is the possibility to add collisions to our Enemy. Let’s fix this by adding a rigidbody component and a box collider component to the Enemy:

a) Add a rigidbody component to the enemy (just clikc Add Component and find Rigidbody inside physics):

b) Set the Constraints so we freeze rotation, movement on the Z-axis and remove the tick from User Gravity. This is becuse we don’t want any outside forces to change the rotation or Z-position of our enemy.

c) Add a box collider to the Enemy:

d) Make sure the properties of the box collider so it surrounds our enemy object, including the Z-axis. This should happen automatically:

The last thing we need to do is to tag the enemy so we can find it and test collisions easily. To do this, we need to create a new tag for the enemy:

a) Do this by clicking the tags property on our enemy and then Add Tag..

b) Name the tag “Enemy”

c) Click the Enemy game object in the hierarchy view and set the tag to the new Enemy-tag:

Now, in the enemy script – for now, what we want to do is to remove the enemy form the scene if the position is behind our player (no need for it anymer) and if it hits the player. Make the following changes to our script:

using UnityEngine;
using System.Collections;

public class EnemyHandler : MonoBehaviour
{
    float speed = 4.0f;
    GameObject player;

    void OnCollisionEnter(Collision collision)
    {
        if (collision.rigidbody != null)
        {
            if (collision.rigidbody.name == “Player”)
            {
                Destroy(this.gameObject);
            }
        }
    }
    // Use this for initialization
    void Start()
    {
        GameObject _p = GameObject.Find(“Player”);
        if (_p != null)
        {
            player = _p;
        }
    }

    // Update is called once per frame
    void Update()
    {
        Vector3 moveVector = Vector3.left;
        transform.position += moveVector * speed * Time.deltaTime;

        if (player != null)
        {
            if (this.transform.position.x <= player.transform.position.x – 10.0f)
            {
                Destroy(this.gameObject);
            }
        }
    }
}

This implements the collision handler, checks it it collides with “Player” and if yes, remove itself from the world!

We also remove it if it walks too far behind us where we don’t need it anymore.

Right now the background is also collidable. Click the background prefab from the prefabs folder:

Uncheck the mesh collider:

This makes sure our enemies wont collide with the background.

III. Making collisions possible

To make collisions possible, we must do the same thing for our player. Go ahead and add a rigidbody to the player, and set the Constraints for the same reasons as with the enemy:

Also, add a box collider:

If you want to test this, move the enemy somewhere a bit in front of the player and press play. When the enemy crash with the player, it is removed. Also, replay the scene to test if the player is removed when walking past you (you can see that the enemy gameobject is removed from the scene hierarchy).

IV. Spawning the enemy

We want to create a logic that automatically spawns enemies over time. Let’s create a new script called GameHandler in the Scripts-folder:

Attach it to the Main Camera of the scene:

Perfect!

Now, we must make the enemy to a prefab so we can spawn with our script. Drag the enemy from the hierarchy to the Prefabs folder as we did with the background:

Delete if from the scene:

The next thing we need is to script the GameHandler so it spawns new enemies. Open the script, it will look like this:

using UnityEngine;
using System.Collections;

public class GameHandler : MonoBehaviour {

    // Use this for initialization
    void Start () {
   
    }
   
    // Update is called once per frame
    void Update () {
   
    }
}

The first thing we want to do is to add a level variable. This will be used to indicate how far in to the game we are.

using UnityEngine;
using System.Collections;

public class GameHandler : MonoBehaviour {
    public int level;
    // Use this for initialization
    void Start () {
   
    }
   
    // Update is called once per frame
    void Update () {
   
    }
}

Now, add another variable that will spawn our enemies based on what the level indicator says.

using UnityEngine;
using System.Collections;

public class GameHandler : MonoBehaviour {
    public int level;

    float spawnNewEnemyTimer = 10;
    // Use this for initialization
    void Start () {
    }
   
    // Update is called once per frame
    void Update () {
        spawnNewEnemyTimer -= Time.deltaTime;
        if (spawnNewEnemyTimer <= 0)
        {
            spawnNewEnemyTimer = 5 – (level * 0.25f);
        }
    }
}

We start by spawning a new enemy after 10 seconds (to give the player some time to start). Once the level starts increaseing the time it takes before a new enemy is spawned is reduced slightly.

Then we add the enemy prefab and the player variable – we need the enemy to instansiate and then we need the player for other stuff like where to spawn a new enemy:

using UnityEngine;
using System.Collections;

public class GameHandler : MonoBehaviour
{
    public int level;
    public GameObject enemy;
    public GameObject player;

    float spawnNewEnemyTimer = 10;

    // Use this for initialization
    void Start()
    {
    }

    // Update is called once per frame
    void Update()
    {
        spawnNewEnemyTimer -= Time.deltaTime;
        if (spawnNewEnemyTimer <= 0)
        {
            spawnNewEnemyTimer = 5 – (level * 0.25f);
        }
    }
}

This means that we can instansiate a new enemy whenever we want! Let’s do this next:

using UnityEngine;
using System.Collections;

public class GameHandler : MonoBehaviour
{
    public int level;
    public GameObject enemy;
    public GameObject player;

    float spawnNewEnemyTimer = 10;

    // Use this for initialization
    void Start()
    {
    }

    // Update is called once per frame
    void Update()
    {
        spawnNewEnemyTimer -= Time.deltaTime;
        if (spawnNewEnemyTimer <= 0)
        {
            spawnNewEnemyTimer = 5 – (level * 0.25f);
            Instantiate(enemy, new Vector3(player.transform.position.x + 50.0f,
                    player.transform.position.y, 0.0f), Quaternion.identity);
        }
    }
}

Go back to the editor and set the missing properties on the Main Cameras GameHandler script:

(remember, the Enemy is set to the Enemy prefab)

Press play to see the script in action. A new enemy is spawned every 5 seconds 50 units in front of the player.

We will work more with the logic of levels and so on later. First, we need to be able to make our player shoot.

V. Creating the laser prefab

The laser will be a quad that will move at a speed towards the right side of the screen, untill it hits a player or goes too far.

Start by create an empty gameobject:

Add a quad to the Laser GameObject:

Resize the laser using scale to the following:

Create a new Material called LaserMaterial to the Materials folder:

Give it the tint color of red:

Now, assign the material to the lasers texture object:

It should now look something like this:

Next, we must add a rigidbody and a boxcollider to it:

First, add the rigidbody and make the constraits and gravity as the following:

Also, add a box collider:

It will now look something like this:

The last thing we need to do is to is to set the Shader of the LaserMaterial to Mobile/Particles/VertexLit Blend:

VI. Scripting the laser

Create a new script called LaserHandler to our Scripts folder:

Assign this script to the Laser gameobject:

Great! It’s time to give the laser some logic. Edit the script and make it move towards the right side of the screen:

using UnityEngine;
using System.Collections;

public class LaserHandler : MonoBehaviour {
    float speed = 16.0f;
    float aliveTimer = 2.0f;

    // Use this for initialization
    void Start () {
   
    }
   
    // Update is called once per frame
    void Update () {
        aliveTimer -= Time.deltaTime;

        if (aliveTimer > 0.0f)
        {
            transform.position += Vector3.right * speed * Time.deltaTime;
        }
        else
        {
            Destroy(this.gameObject);
        }
    }
}

This will make the laser move, and be destroyed after two seconds if it haven’t hit anything yet.

Now, create a prefab out of the laser gameobject by draging it to the Prefabs folder:

Delete it from the scene:

Now that our Laser is ready for spawning, we must change our player script to enable shooting:

using UnityEngine;
using System.Collections;

public class PlayerHandler : MonoBehaviour {
    float speed = 4.0f;
    public GameObject laserPrefab;

    float shootTimer = 0.0f;
    float setShootTimerTo = 0.5f;

    // Use this for initialization
    void Start () {
   
    }
   
    // Update is called once per frame
    void Update () {
        Vector3 movePlayerVector = Vector3.right;
        shootTimer -= Time.deltaTime;

        if (Input.GetMouseButton(0))
        {
            Vector3 touchWorldPoint = Camera.main.ScreenToWorldPoint(
                new Vector3(Input.mousePosition.x,
                            Input.mousePosition.y,
                            10.0f));

            if (touchWorldPoint.x < this.transform.position.x + 5.0f)
            {
                if (touchWorldPoint.y > this.transform.position.y)
                {
                    movePlayerVector.y = 1.0f;
                }
                else movePlayerVector.y = -1.0f;
            }
            else
            {
                if (shootTimer <= 0)
                {
                    Vector3 shootPos = this.transform.position;
                    shootPos.x += 2;
                    Instantiate(laserPrefab, shootPos, Quaternion.identity);
                    shootTimer = setShootTimerTo;
                }
            }
        }

        this.transform.position += movePlayerVector * Time.deltaTime * speed;

        if (transform.position.y > -2.0)
        {
            transform.position = new Vector3(transform.position.x,
                                            -2.0f,
                                            transform.position.z);
        }

        if (transform.position.y < -5.5)
        {
            transform.position = new Vector3(transform.position.x,
                                            -5.5f,
                                            transform.position.z);
        }
    }
}

What we do here is to create a variable that holds the laserPrefab, and a timer that controls how frequent we are able to shoot.

Then we change how the input works. If we touch on the left side of the screen it will move our player, if we touch the right side it will shoot. Should not be anything new here!

If you play the scene now, you should be able to shoot the lasers! But when we hit an enemy with a laser, it will just push the enemy away. Let’s open the enemy script again and make sure that if a laser hits it, it will destroy both the laser and the enemy.

Edit the EnemyHandler script with the following modifications:

using UnityEngine;
using System.Collections;

public class EnemyHandler : MonoBehaviour
{
    float speed = 4.0f;
    GameObject player;

    void OnCollisionEnter(Collision collision)
    {
        if (collision.rigidbody != null)
        {
            if (collision.rigidbody.name == “Player”)
            {
                Destroy(this.gameObject);
            }

            if (collision.rigidbody.tag == “Laser”)
            {
                Destroy(this.gameObject);
                Destroy(collision.gameObject);
            }
        }
    }
    // Use this for initialization
    void Start()
    {
        GameObject _p = GameObject.Find(“Player”);
        if (_p != null)
        {
            player = _p;
        }
    }

    // Update is called once per frame
    void Update()
    {
        Vector3 moveVector = Vector3.left;
        transform.position += moveVector * speed * Time.deltaTime;

        if (player != null)
        {
            if (this.transform.position.x <= player.transform.position.x – 10.0f)
            {
                Destroy(this.gameObject);
            }
        }
    }
}

Now, what we are doing here is to check it the laser got the tag Laser, and then if yes, destroy both.

This script won’t work before we set the Laser to the “Laser” tag. Click the Laser prefab:

And add a new tag called “Laser”:

And set the tag of the Laser prefa to “Laser”:

Play the game again, and you will be able to shoot lasers, destroy enemies and move the player! It sure starts looking like a game now!

Whats next and download the source

This concludes this tutorial, in the next part we will implement explosions, a system where the player can get XP and Level ups (making the game harder), loose health and die.

We will also create a simple UI so we can see what’s going on.

You can download the project, source and game assets here.

In this tutorial, we will continue on what we created in the previous tutorial.

I. Making the camera follow the player

The first thing we want to do is to make the camera follow the player. Find the Standard Assets (Mobile) script folder:

Now, drag the script named SmoothFollow2d and set it on the Main Camera:

Put it on Main Camera:

You should now see it added as a component of the camera:

Now, we need to set the target to the player. Drag the Player GameObject from the hierarchy to the target property of the component:

a)

b)

c)

If you press play now, the camera will center on the player object.

II. Controlling the player

Create a new script in our Scripts folder and name it “PlayerHandler”.

Drag it on the Player GameObject in the hierarchy view and make sure it’s added:

Now, edit this script. Our goal is to move it up and down by input, and then we are walking forward automatically. How should we control the character? First of all, this is going to be an app for both tablets and phones, so touch/mouse is essential. At a later tutorial, we will add keybaord and Xbox360 controller support too (easy to do! ).

This script is a start, covering the touch/mouse input:

using UnityEngine;
using System.Collections;

public class PlayerHandler : MonoBehaviour {
    float speed = 4.0f;
    public GameObject go;
    // Use this for initialization
    void Start () {
   
    }
   
    // Update is called once per frame
    void Update () {
        Vector3 movePlayerVector = Vector3.right;

        if (Input.GetMouseButton(0))
        {
            Vector3 touchWorldPoint = Camera.main.ScreenToWorldPoint(
                new Vector3(Input.mousePosition.x,
                            Input.mousePosition.y,
                            10.0f));

            if (touchWorldPoint.y >= this.transform.position.y)
            {
                movePlayerVector.y = 1.0f;
            }
            else movePlayerVector.y = -1.0f;
        }

        this.transform.position += movePlayerVector * Time.deltaTime * speed;
    }
}

First of all we create a vector that’s pointing right. This vector is then added to the players position later. This means that we are always walking right. This vector is 1.0 on the X-axis and 0.0 on the Y-axis.

We need to modify this vector with the Y-axis to make our character move up and down.

We check for input from the left mouse button (the same as a touch point). If it is being pressed, take the mouse coordinate and convert it to world view (since when we click the mouse/touch the screen, the position of the location we touched is in screen-space (screen resolution). We need to convert it to world space (the same coordinate system that our player is in).

Now, it’s hard to see anything without a background. Let’s add this!

III. Adding the background

This section will cover how to add a background to our game.

a) First, add a new quad to our scene:

b) And name it “Background”:

c) Set the position to 0,0,0:

d) Create a new material and name it “BackgroundMaterial”:

e) Set the texture of the material to the “Background.png” texture in “Textures\Environment”:

f) Set the shader to Mobile/Background:

The reason for this is that we don’t want any lighting on our scene, since it’s 2D. This shader will just use the colors set when creating the image using your favorite drawing application.

g) Set the scale of the Background GameObject to the same aspect as the texture resolution, something that fit the scene. We also set the Positions Z azis to one, so it’s a bit behind our player:

The result should be something like this:

IV. Looping the background

Next we need to loop the background. We want an infinite world. We could duplicate the Background GameObject many times and line them up together, or we can make a prefab out of it, and then use a script to draw a lot of them!

Create a new folder in the Assets/Game folder and name it Prefabs:

Next, create a new C# script in the Scripts-folder named EnvironmentHandler:

Drag this script on the Main Camera GameObject.

Now, browse to the Prefabs-folder:

Then drag the Background GameObject from the scene hierarchy to the Prefabs-folder to create a prefab out of it:

Then delete the Background GameObject from the scene hierarchy:

Now, open the EnvironmentHandler-script, and write the following code:

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class EnvironmentHandler : MonoBehaviour {
    public GameObject BackgroundPrefab;
    public GameObject Player;

    List<GameObject> spawnedBackgrounds = new List<GameObject>();

    int spawnIndex = 2;

    // Use this for initialization
    void Start () {
        for (int i = 0; i < spawnIndex; i++)
        {
            spawnedBackgrounds.Add(
                (GameObject)Instantiate(BackgroundPrefab,
                                        new Vector3(i * 51.2f + 25.6f, 0, 0.01f),
                                        Quaternion.identity)
                );
        }
    }

    // Update is called once per frame
    void Update()
    {
        bool addNewBackground = false;
        foreach (GameObject bgObject in spawnedBackgrounds)
        {
            if (bgObject != null)
            {
                if (bgObject.activeInHierarchy)
                {
                    float distanceFromPlayer =
                          Player.transform.position.x – bgObject.transform.position.x;

                    if (distanceFromPlayer > 51.2f)
                    {
                        Destroy(bgObject);
                        bgObject.SetActive(false);
                        addNewBackground = true;
                    }
                }
            }
        }

        if (addNewBackground)
        {
            spawnedBackgrounds.Add(
                (GameObject)Instantiate(BackgroundPrefab,
                                        new Vector3(spawnIndex * 51.2f + 25.6f, 0, 0.01f),
                                        Quaternion.identity));
            spawnIndex++;
        }
    }
}

Oh, another script that looks complex! Again, I wrote this to have a simple code so it would be easy to understand the goal and logic of it, not efficient so if you need a place to optimize, this is a place to test out (but it should be good enought ).

So… what is this script doing?
It’s simple – what we want is to render two backgrounds on our scene. If one background is behind us, remove it and spawn a new infront of us.

When we start the level, two Background GameObjects are spawned. These are positioned at the scenes origin (where the player starts) – 25.6f. This number is the width of the background game object divided by two. This is to make sure that we don’t get half the screen empty in the first run like this:

The image shows the blue area where there isnt yet a part of our background object since they havent scrolled there yet (or the player havent moved away from the start position yet). By subtracting this, we move all the background objects 25.6f to the left.

Next, we check the distance of the backgrounds behind the player, and if any of them are further away than 51.2 (that’s the length of the entire background gameobject), we remove it and tell the code that we want to add a new in front.

spawnIndex is used to remember where in the world we are.

On the Main Camera where the EnvironementHandler script is attached, drag the new Background-prefab to the Background Prefab property, and our Player-prefab to the Player property:

Now, test to see if we are moving forward, and that you can move the player up and down with the mouse/touch-screen.

V. Making sure the camera is “inside” our environment

As you probably see, we can move the player outside of the invironment. And even if we don’t, some of the environments edges are inside of the view, making it possible to see the blue background color of our scene.

It’s time to remove this artifact, something we will do on the script that we attached to our Main Camera earlier.

Click on the Main Camera GameObject, and edit the script attached to it by doubleclicking it:

Change the script with the following modifications:

#pragma strict

var target : Transform;
var smoothTime = 0.3;
private var thisTransform : Transform;
private var velocity : Vector2;

function Start()
{
    thisTransform = transform;
}

function Update()
{
    thisTransform.position.x = Mathf.SmoothDamp( thisTransform.position.x,
        target.position.x, velocity.x, smoothTime);
   
    thisTransform.position.y = -0.5;
}

This will lock the cameras Y-axis to the given position.

Try running the scene again and we can see that the camera is now placed on –0.5 on the Y-axis (this coordinate was found by trail and error based on where the sidewalk on the texture is).

VI. Making sure our player is on the sidewalk

The last thing we will do today is to make sure the player is inside the sidewalk. We do this the same way as with the camera, but inside the PlayerHandler-script. Here we will limit the minimum and maximum value of the players Y-position.

This is very simple. We check that the player is between –2.0 and – 5.5 (found by trial and error). If you press Play on the scene, move the player to the top part of the sidewalk:

..and then click the Player in the scene hierarchy to view the properties, you can see that Y is around –2.0. This is the method I used to create these bounds.

using UnityEngine;
using System.Collections;

public class PlayerHandler : MonoBehaviour {
    float speed = 4.0f;
    // Use this for initialization
    void Start () {
   
    }
   
    // Update is called once per frame
    void Update () {
        Vector3 movePlayerVector = Vector3.right;

        if (Input.GetMouseButton(0))
        {
            Vector3 touchWorldPoint = Camera.main.ScreenToWorldPoint(
                new Vector3(Input.mousePosition.x,
                            Input.mousePosition.y,
                            10.0f));

            if (touchWorldPoint.y > this.transform.position.y)
            {
                movePlayerVector.y = 1.0f;
            }
            else movePlayerVector.y = -1.0f;
        }

        this.transform.position += movePlayerVector * Time.deltaTime * speed;

        if (transform.position.y > -2.0)
        {
            transform.position = new Vector3(transform.position.x,
                                            -2.0f,
                                            transform.position.z);
        }

        if (transform.position.y < -5.5)
        {
            transform.position = new Vector3(transform.position.x,
                                            -5.5f,
                                            transform.position.z);
        }
    }
}

Now, pressing play again – you can see that we can move our robot up and down, he is kept between the bounds of the sidewalk and the camera is inside the environment.

The last thing we want to do is to set the target of our player a bit in front of us, so that we can see longer in to the scene than what we can do now.

Right now it’s:

This is simple. Add a new empty GameObject to our scene and drag it inside our Player Game Object. Give it the name “CameraTarget” and position position to 6,0,0

a) Create the GameObject, put it inside the player and set the name to CameraTarget

b) Set the position to 6,0,0

Next, we set this as the target for our SmoothFollow2d script on our Main Camera.

Click the Main Camera GameObject:

Drag the CameraTarget from the Hierarchy to the target property of the script:

Now, run the game again and you can see that our visibility is much better!

In the next tutorial, we will create the enemies and spawn them. We will also make is possible to shoot them with our laser!

Download project, sources and assets here.