Unity Game Development Blueprints

With Unity started, go to File | New Project. Select Project Location of your choice somewhere on your hard drive, and ensure you have Setup defaults for set to 2D. Once completed, select Create. At this point, we will not need to import any packages, as we'll be making everything from scratch. It should look like the following screenshot:

From there, if you see the Welcome to Unity pop up, feel free to close it out as we won't be using it. At this point, you will be brought to the general Unity layout, as follows:

Click on the Create drop-down menu below the Project tab in the bottom-left side of the screen.

From there, click on Folder, and you'll notice that a new folder has been created inside your Assets folder.

After the folder is created, you can type in the name for your folder. Once done, press Enter for the folder to be created. We need to create folders for the following directories:

Once you're done with the aforementioned steps, your project should look something like this:

Double-click on the Sprites folder. Once inside, go to your operating system's browser window, open up the Chapter 1/Assets folder that we provided, and drag the playerShip.png file into the folder to move it into our project. Once added, confirm that the image is Sprite by clicking on it and confirming from the Inspector tab that Texture Type is Sprite (Sprite (2D and UI) in 4.6). If it isn't, simply change it to that, and then click on the Apply button. Have a look at the following screenshot:

Next, drag-and-drop the ship into the Scene tab (the center part that's currently dark gray). Once completed, set the position of the sprite to the center of the Screen (0, 0) by right-clicking on the Transform component and then selecting Reset Position. Have a look at the following screenshot:

Now, with the player in the world, let's add in a background. Drag-and-drop the background.png file into your Sprites folder. After that, drag-and-drop a copy into the scene.

If you put the background on top of the ship, you'll notice that currently the background is in front of the player (Unity puts newly added objects on top of previously created ones if their position on the Z axis is the same; this is commonly referred to as the z-order), so let's fix that.

Select your background object, and go to the Sprite Renderer component from the Inspector tab. Under Sorting Layer, select Add Sorting Layer. After that, click on the + icon for Sorting Layers, and then give Layer 1 a name, Background. Now, create a sorting layer for Foreground and GUI. Have a look at the following screenshot:

Now, place the player ship on the foreground and the background by selecting the object once again and then setting the Sorting Layer property via the drop-down menu. Now, if you play the game, you'll see that the ship is in front of the background, as follows:

At this point, we can just duplicate our background a number of times to create our full background by selecting the object in the Hierarchy, but that is tedious and time-consuming. Instead, we can create all the duplicates by either using code or creating a tileable texture. For our purposes, we'll just create a texture.

Delete the background sprite by left-clicking on the background object in the Hierarchy tab on the left-hand side and then pressing the Delete key. Then select the background sprite in the Project tab, change Texture Type in the Inspector tab to Texture, and click on Apply.

Now let's create a 3D cube by selecting Game Object | Create Other | Cube from the top toolbar. Change the object's name from Cube to Background. In the Transform component, change the Position to (0, 0, 1) and the Scale to (100, 100, 1).

Since our camera is at 0, 0, -10 and the player is at 0, 0, 0, putting the object at position 0, 0, 1 will put it behind all of our sprites. By creating a 3D object and scaling it, we are making it really large, much larger than the player's monitor. If we scaled a sprite, it would be one really large image with pixelation, which would look really bad. By using a 3D object, the texture that is applied to the faces of the 3D object is repeated, and since the image is tileable, it looks like one big continuous image.

Remove Box Collider by right-clicking on it and selecting Remove Component.

Next, we will need to create a material for our background to use. To do so, under the Project tab, select Create | Material, and name the material as BackgroundMaterial. Under the Shader property, click on the drop-down menu, and select Unlit | Texture. Click on the Texture box on the right-hand side, and select the background texture. Once completed, set the Tiling property's x and y to 25. Have a look at the following screenshot:

Finally, go back to the Background object in Hierarchy. Under the Mesh Renderer component, open up Materials by left-clicking on the arrow, and change Element 0 to our BackgroundMaterial material. Consider the following screenshot:

Right-click on the Scripts folder you created earlier, click on Create, and select the C# Script label. Once you click on it, a script will appear in the Scripts folder, and it should already have focus and should be asking you to type a name for the script—call it PlayerBehaviour.

Double-click on the script in Unity, and it will open MonoDevelop, which is an open source integrated development environment (IDE) that is included with your Unity installation.

Delete the Start function and its contents.

The next function that we see included is the Update function. Also inherited from MonoBehaviour, this function is called for every frame that the component exists in and for each object that it's attached to. We want to update our player ship's rotation and movement every turn.

Inside the Update function (between { and }), put the following lines of code:

// Rotate player to face mouse
Rotation();
// Move the player's body
Movement();

Here, I called two functions, but these functions do not exist, because we haven't created them yet, which is why the text shows up as Red inside of MonoDevelop. Let's do that now!

Below the Update function and before } that closes the class at the end of the file, put the following function to close the class:

// Will rotate the ship to face the mouse.
void Rotation()
{
  // We need to tell where the mouse is relative to the 
  // player
  Vector3 worldPos = Input.mousePosition;
  worldPos = Camera.main.ScreenToWorldPoint(worldPos);

  /*
   * Get the differences from each axis (stands for 
   * deltaX and deltaY)
   */
  float dx = this.transform.position.x - worldPos.x;
  float dy = this.transform.position.y - worldPos.y;

  // Get the angle between the two objects
  float angle = Mathf.Atan2(dy, dx) * Mathf.Rad2Deg;

  /* 
    * The transform's rotation property uses a Quaternion, 
    * so we need to convert the angle in a Vector 
    * (The Z axis is for rotation for 2D).
  */
  Quaternion rot = Quaternion.Euler(new Vector3(0, 0, angle + 90));

  // Assign the ship's rotation
  this.transform.rotation = rot;
}

Now if you comment out the Movement line and run the game, you'll notice that the ship will rotate in the direction in which the mouse is. Have a look at the following screenshot:

Below the Rotation function, we now need to add in our Movement function the following code. Uncomment the Movement function call if you commented it out earlier:

// Will move the player based off of keys pressed
void Movement()
{
  // The movement that needs to occur this frame
  Vector3 movement = new Vector3();

  // Check for input
  movement += MoveIfPressed(upButton, Vector3.up);
  movement += MoveIfPressed(downButton, Vector3.down);
  movement += MoveIfPressed(leftButton, Vector3.left);
  movement += MoveIfPressed(rightButton, Vector3.right);

  /* 
    * If we pressed multiple buttons, make sure we're only 
    * moving the same length.
  */
  movement.Normalize ();

  // Check if we pressed anything
  if(movement.magnitude > 0)
  {
    // If we did, move in that direction
    currentSpeed = playerSpeed;
    this.transform.Translate(movement * Time.deltaTime * playerSpeed, Space.World);
    lastMovement = movement;
  }
  else
  {
    // Otherwise, move in the direction we were going
    this.transform.Translate(lastMovement * Time.deltaTime * currentSpeed, Space.World);
    // Slow down over time
    currentSpeed *= .9f;
  }
}

Now inside this function I've created another function called MoveIfPressed, so we'll need to add that in as well.

Below this function, add in the following function as well:

/* 
  * Will return the movement if any of the keys are pressed,
  * otherwise it will return (0,0,0)
*/
Vector3 MoveIfPressed( List<KeyCode> keyList, Vector3 Movement)
{
  // Check each key in our list
  foreach (KeyCode element in keyList)
  {
    if(Input.GetKey(element))
    {
      /*
        * It was pressed so we leave the function 
        * with the movement applied.
      */
      return Movement;
    }
  }

  // None of the keys were pressed, so don't need to move
  return Vector3.zero;
}

Now, save your file and move back into Unity. Save your current scene as Chapter_1.unity by going to File | Save Scene. Make sure to save the scene to our Scenes folder we created earlier.

Run the game by pressing the play button. Have a look at the following screenshot:

Open up the PlayerBehaviour script. In the top section where the other variables are present, we need to add some additional ones that we'll use:

// The laser we will be shooting
public Transform laser;

// How far from the center of the ship should the laser be
public float laserDistance = .2f;

// How much time (in seconds) we should wait before 
// we can fire again
public   float   timeBetweenFires = .3f;

// If value is less than or equal 0, we can fire
private float timeTilNextFire = 0.0f;

// The buttons that we can use to shoot lasers
public List<KeyCode> shootButton;

One thing you may have noticed is that we have a laser variable that is of the type Transform. This is the laser we'll fire, which we will create shortly.

Inside our Update function, we will need to add some additional code, which is as follows:

// a foreach loop will go through each item inside of 
// shootButton and do whatever we placed in {}s using the 
// element variable to hold the item
foreach (KeyCode element in shootButton)
{
  if(Input.GetKey(element) && timeTilNextFire < 0)
  {
    timeTilNextFire = timeBetweenFires;
    ShootLaser();
    break;
  }
}

timeTilNextFire -= Time.deltaTime;

In a manner very similar to what we did before with the player movement, we check each of the keys we allow the player to shoot with (such as the spacebar and Enter keys). If they press any of these keys and can fire again, then we will reset our timer and shoot a laser. However, we haven't made the ShootLaser function. Let's do that now.

Underneath the functions, add the following function:

// Creates a laser and gives it an initial position in front 
// of the ship.    
void ShootLaser()
{
  // calculate the position right in front of the ship's
  // position lazerDistance units away
  float posX = this.transform.position.x + 
               (Mathf.Cos((transform.localEulerAngles.z - 90) * Mathf.Deg2Rad) * -laserDistance);
  float posY = this.transform.position.y + (Mathf.Sin((transform.localEulerAngles.z - 90) * Mathf.Deg2Rad) * -laserDistance);
  
  Instantiate(laser, new Vector3 (posX, posY, 0), this.transform.rotation);
}

Save your file, and go back into Unity. You'll now see a number of additional variables that we can now set. Be sure to set the Shoot Button variable in the same manner that we did the movement buttons, changing the Size to 2 and setting Element 0 to Mouse0 and Element 1 to Space.

Next, we will need to create our laser. Go back into our Assets folder from the example code, and move the laser.png file into our Project tab's Sprites folder.

Following that, drag-and-drop it into your scene from the Scene tab to place it in the level.

Right-click the Scripts folder you created earlier, click on Create, and select the C# Script label. Call this new script LaserBehaviour. Go into MonoDevelop, and use the following code:

using UnityEngine;
using System.Collections;

public class LaserBehaviour : MonoBehaviour 
{
  // How long the laser will live
  public float lifetime = 2.0f;

  // How fast will the laser move
  public float speed = 5.0f;


  // How much damage will this laser do if we hit an enemy
  public int damage = 1;

  // Use this for initialization
  void Start () 
  {
    // The game object that contains this component will be
    // destroyed after lifetime seconds have passed
    Destroy(gameObject, lifetime);
  }
  
  // Update is called once per frame
  void Update () 
  {
    transform.Translate(Vector3.up * Time.deltaTime * speed);
  }
}

Attach LaserBehaviour to the laser object. Finally, add a Box Collider component by first selecting the laser object and then going to Component | Physics 2D | Box Collider 2D. The collision box, by default, will be the size of the image, but I want to shrink it to fit what is visually seen of it. To do that, we will change the Size attribute's X property to .06 and Y to .5.

Now, the laser will move in the direction that it's facing and die after a period of 2 seconds! Next, let's make it so that the player can shoot them.

In the Project tab, go to the Assets | Prefabs folder, and drag-and-drop the laser object from our Hierarchy tab into it. You'll notice that the object Hierarchy will turn blue to show that it is a prefab.

Have a look at the following screenshot:

Now, delete the laser object from our scene, and then go to the playerShip object. Drag-and-drop the laser prefab into the Laser property of the PlayerBehavior component.

Finally, add a circle collider to our ship by going to Component | Physics 2D | Circle Collider 2D. Change the Radius property to .3.

Exit the game and access our example code's Assets folder; move the enemy.png file into our Sprites folder.

Following that, drag-and-drop it into your scene from the Scene tab to place it in the level.

Right-click on the Scripts folder you created earlier, click on Create, and select the C# Script label. Call this new script MoveTowardsPlayer. Go to MonoDevelop and use the following code:

using UnityEngine;
using System.Collections;

public class MoveTowardsPlayer : MonoBehaviour 
{
  private Transform player;
  public float speed = 2.0f;

  // Use this for initialization
  void Start () 
  {
    player = GameObject.Find("playerShip").transform;
  }
  
  // Update is called once per frame
  void Update () 
  {
    Vector3 delta = player.position - transform.position;
    delta.Normalize();
    float moveSpeed = speed * Time.deltaTime;
    transform.position = transform.position + (delta * moveSpeed);
  }
}

In the beginning of the game, I find the player ship and get his transform component. Then, in every frame of the project, we move the enemy from where it currently is to the direction where the player is at.

Drag-and-drop this newly added behavior onto our enemy object.

Next, add a circle collider to our enemy by going to Component | Physics 2D | Circle Collider 2D. Change the Radius property to .455, and run the game. Have a look at the following screenshot:

Right-click on the Scripts folder you created earlier, click on Create, and select the C# Script label. Call this new script EnemyBehaviour. Go to MonoDevelop, and use the following code:

using UnityEngine; // MonoBehaviour

public class EnemyBehaviour : MonoBehaviour 
{

  // How many times should I be hit before I die
  public int health = 2;

  void OnCollisionEnter2D(Collision2D theCollision)
  {
    // Uncomment this line to check for collision
    //Debug.Log("Hit"+ theCollision.gameObject.name);

    // this line looks for "laser" in the names of 
    // anything collided.
    if(theCollision.gameObject.name.Contains("laser"))
    {
      LaserBehaviour laser = theCollision.gameObject.GetComponent("LaserBehaviour") as LaserBehaviour;
      health -= laser.damage;
      Destroy (theCollision.gameObject);
    }
    
    if (health <= 0) 
    {
      Destroy (this.gameObject);
    }
  }
}

Now, you will notice that we have commented a line of code calling the function Debug.Log. This function will print something onto your console, which may help you when debugging your own code in the future.

Save the file, and then go back into Unity. Attach the EnemyBehaviour behavior to your enemy object. For collision events to register we need to add a Rigidbody 2D component to our enemy by going to Component | Physics 2D | Rigidbody 2D. Change the Gravity Scale to 0 so it will not fall. Have a look at the following screenshot:

First, create an empty game object by going to GameObject | Create Empty. From there, with the object selected, go to Inspector and set its name to GameController, and optionally, for neatness sake, set its Position to (0, 0, 0).

Underneath the name, you'll see the Tag property. Change it from Untagged to GameController.

Next, select Add Component | New Script, and once you are brought to the next menu, change the language to C# (C Sharp), and set the name of the script to GameController. Then press Enter or click on Create and Add.

Select the newly created script in the Assets folder of the Project tab, and move it to the Assets\Scripts folder. Go to MonoDevelop by double-clicking on the script file.

While our game does many things, the most important thing is the spawning of enemies, which is what we'll be adding in first. Let's create a variable to store our enemy.

Inside of the class definition, add the following variable and then save the file:

// Our enemy to spawn
public Transform enemy;

Now, we can set the enemy that we currently have in the scene, but we should instead make the enemy a prefab and use it. To do so, drag the enemy from Hierarchy into your Assets\Prefabs folder. Once we've created the prefab, we can remove the enemy object from our scene by deleting it.

Next, drag-and-drop the enemy prefab into the Enemy variable in the GameController component.

Next, go back into our GameController script by double-clicking it to go into MonoDevelop. Add the following additional variables to the component:

// We want to delay our code at certain times
public float timeBeforeSpawning = 1.5f;
public float timeBetweenEnemies = .25f;
public float timeBeforeWaves = 2.0f;

public   int enemiesPerWave = 10;
private int currentNumberOfEnemies = 0;

We now need a function to spawn enemies; let's call it SpawnEnemies. We don't want to spawn all the enemies at once. What we want is a steady stream of enemies to come to the player over the course of the game. However, in C#, to have a function pause the gameplay without having to stop the entire game, we need to use a coroutine that looks different from all the code that we've used so far.

Inside the Start method, add the following line:

StartCoroutine(SpawnEnemies());

Now that we are already using the function, let's add in the SpawnEnemies function as follows:

// Coroutine used to spawn enemies
IEnumerator SpawnEnemies()
{
  // Give the player time before we start the game
  yield return new WaitForSeconds(timeBeforeSpawning);

  // After timeBeforeSpawning has elapsed, we will enter this loop
  while(true)
  {
    // Don't spawn anything new until all the previous
    // wave's enemies are dead
    if(currentNumberOfEnemies <= 0) 
    {
      float randDirection;
      float randDistance;

      //Spawn 10 enemies in a random position
      for (int i = 0; i < enemiesPerWave; i++) 
      {
        // We want the enemies to be off screen
        // (Random.Range gives us a number between the 
        // first and second parameter)
        randDistance = Random.Range(10, 25);

        // Enemies can come from any direction
        randDirection = Random.Range(0, 360);

        // Using the distance and direction we set the position
        float posX = this.transform.position.x + (Mathf.Cos((randDirection) * Mathf.Deg2Rad) * randDistance);
        float posY = this.transform.position.y + (Mathf.Sin((randDirection) * Mathf.Deg2Rad) * randDistance);

        // Spawn the enemy and increment the number of 
        // enemies spawned 
        // (Instantiate Makes a clone of the first parameter 
        // and places it at the second with a rotation of 
        // the third.)
        Instantiate(enemy, new Vector3 (posX, posY, 0), this.transform.rotation);
        currentNumberOfEnemies++;
        yield return new WaitForSeconds(timeBetweenEnemies);
      }
    }
    // How much time to wait before checking if we need to 
    // spawn another wave
    yield return new WaitForSeconds(timeBeforeWaves);
  }
}

Now, when we destroy an enemy, we want to decrement the number of currentNumberOfEnemies, but it's a private variable, which means that it can only be changed inside the GameController class or one of the methods inside of the class. Simple enough? Now let's add a new function in our GameController class:

// Allows classes outside of GameController to say when we killed 
// an enemy.
public void KilledEnemy()
{
  currentNumberOfEnemies--;
}

Finally, let's go back into our EnemyBehaviour class. Inside the OnCollisionEnter2D function under the Destroy function call, add the following two lines:

GameController controller = GameObject.FindGameObjectWithTag("GameController").GetComponent("GameController") as GameController;
controller.KilledEnemy();

The preceding line gets the script GameController with the tag GameController. The as keyword casts the object to a GameController object. Casting basically tells the computer, "Even though the code says it's some class, I'm telling you that it's another one."

This will call the KilledEnemy function from GameController, onto which we set the GameController tag in step 2.

With all those changes, save both script files and run the game! Have a look at the following screenshot:

Create a new particle system by going to GameObject | Create Other | Particle System. Have a look at the following screenshot:

Once you do this, you should see a default particle system show up. Do note that the system will only animate if it is the object selected and Unity is the active window.

Change the object's name to Explosion. First, under the Particle System tab, change Duration to 1.00, and then uncheck Looping.

Click on the downwards-facing arrow on the right-hand side of Start Lifetime, and change the values to be Random Between Two Constants. Change those values to 0 and 1. Do the same with Start Speed. Make Start Size use random values between 0 and .5.

Next, we will set the object's Start Color value to the same color as the UFO ship (you can use the eyedropper tool or set it to 210, 224, 230) and an Alpha value of 125. Have a look at the following screenshot:

Open the Emission tab, and change Rate to 200. This is how many particles are spawned at a time.

Open the Shape tab, change the Shape property to Sphere, and then set Radius to .35 to fit the rim of the ship. Enable the Random Direction option.

Back in the Explosion section, change the Simulation Space to World; that way, if this object moves, the already-spawned particles will not move.

Now, make this object a prefab by dragging-and-dropping it into the Prefabs folder. After that, delete the Explosion object in your Hierarchy object.

Go back to your EnemyBehaviour script file. We will first want to add in a new variable for us to use to spawn this explosion when it dies:

// When the enemy dies, we play an explosion
public Transform explosion;

Back in Inspector, drag-and-drop your new explosion prefab to fill in the explosion variable slot in our enemy prefab.

Coming back to the EnemyBehaviour script, let's spawn an explosion whenever we die. Inside your if(health <= 0) section of CollisionEnter2D, add in the following lines:

// Check if explosion was set
if(explosion)
{
  GameObject exploder = ((Transform)Instantiate(explosion, this.transform.position, this.transform.rotation)).gameObject;
  Destroy(exploder, 2.0f);
}

Save your script and scene files, and run your project! Have a look at the following screenshot:

Select your enemy prefab, and add an Audio Source component to it by selecting Component | Audio | Audio Source. An audio source lets the audio listener into Main Camera knowing that this is an object that can play sounds. Once you create the Audio Source, open the 3D Sound Settings and change the Min Distance of the Volume Rolloff to 10. Unity will attempt to alter the volume and pan sounds to make the project sound nicer, but for this project, it just makes everything much softer, so we're going to undo the effect unless it's far away.

After this, let's go into our EnemyBehaviour script! As usual, we'll need to add in a new variable for us to use to play whenever we're hit:

// What sound to play when we're hit 
public AudioClip hitSound;

Next, go into the CollisionEnter2D function. After the Destroy(theCollision.gameObject) line, add the following code:

// Plays a sound from this object's AudioSource
audio.PlayOneShot(hitSound);

Back in the inspector for our enemy, let's set the Hit Sound variable in the EnemyBehaviour script to the hit sound that we've imported by using drag-and-drop. Now if we play the game, when we hit an enemy, the sound will be played! Now, let's have a sound if we destroy the enemy!

Go to the Explosion prefab, and add an Audio Source component in the same way we did in step 1. Once you create the audio source, open up the 3D Sound Settings, and change the Min Distance of the Volume Rolloff to 10. After this, set the Audio Clip property in the component to the explode sound.

Now, going back to our EnemyBehaviour script, go to the line after we instantiate the exploder object, and add the following line before we destroy the exploder:

exploder.audio.Play();

Now, if you play the game, hitting the object will play one sound, and when the object is destroyed, the explosion will play a sound. Because the sound is in the Audio Clip property, we can just call the Play function. However, if you want an object to play multiple sounds, it's better to have separate AudioClip variables just as we did with EnemyBehaviour.

Finally, I want to play a sound whenever we fire a shot. To do that, let's go to playerShip and add an audio source. Once you create the audio source, open 3D Sound Settings, and change the Min Distance of Volume Rolloff to 10.

Next, go into PlayerBehaviour, and add in a new variable, as follows:

// What sound to play when we're shooting
public AudioClip shootSound;

After this, whenever we shoot a bullet, let's play the new sound at the beginning of the ShootLasers function:

audio.PlayOneShot(shootSound);

Coming back to Inspector, set the Shoot Sound property in the PlayerBehaviour component to the shoot sound effect.

Finally, let's add in our background music. Go to your Main Camera object in Hierarchy. Add an Audio Source component. There's no need to set Min Distance in this case, because this object is where the audio listener is. Change Audio Clip to bgm, check the Loop option, and set the Volume to .25.

Save everything, and run the game!

Create a new GUI Text object by going to the Hierarchy tab and selecting Create | GUI Text.

After this, switch to the Game tab, as you will be unable to see GUI Text in the Scene view. Note that the game should still not be started as yet, so don't hit the Play button. Have a look at the following screenshot:

Change the GUI Text object's name to Score Counter. Under the GUI Text component, change the Text to Score: 0. After that, change the Position of Transform to (0, 1, 0) to put it on the left-hand side of the screen.

GUI elements are placed in viewport space, which means that the space of the GUI is a value from (0,0) in the bottom-left corner to (1,1) in the top-right corner.

Though this is technically fine, it would be nice to have some space so that the text isn't completely off the screen. To give us a bit of padding, let's set the Pixel Offset property to (10, -10) to move it 10 pixels toward the right-hand side and 10 pixels down. Note that Pixel Offset uses pixel space. Have a look at the following screenshot:

Now that we have the text set up, let's set the font. Drag-and-drop the Font folder into your project. Then set Font to OSP-DIN and Font Size to 25.

Next, duplicate the Score Counter object by right-clicking and selecting Duplicate. Set this duplicate's name to Waves Counter, and change its text to Wave: 0.

Set the Waves Counter object's Position to (1, 1, 0). Then set Anchor to upper right and Pixel Offset to (-10, -10). Have a look at the following screenshot:

Now that we have our text files created, let's now have them function correctly! First, let's go into the GameController class. Inside, we need to create some new variables as follows:

// The values we'll be printing
private int score = 0;
private int waveNumber = 0;

// The actual GUI text
public GUIText scoreText;
public GUIText waveText;

Next, we will need to add a function to call whenever our score increases, as follows:

public void IncreaseScore(int increase)
{
  score += increase;
  scoreText.text = "Score: " + score;
}

The += operator will take the current value and add the right-hand side's value to it.

Then, we'll need to call this function inside our EnemyBehaviour component. After the controller.KilledEnemy() line, add the following line:

controller.IncreaseScore(10);

Finally, whenever we increase the wave number we need to change its text as well. Back in the GameController class after the if(currentNumberOfEnemies <= 0) line, add the following lines:

waveNumber++;
waveText.text = "Wave: " + waveNumber;

The ++ operator will take the current value of a number and increment it by 1.

Save all the script files, go back to Inspector, and set the Score Text and Wave Text objects to the proper variables. After that, run the game. Have a look at the following screenshot:

Go to File | Build Settings. From here, you can decide which platforms and/or scenes to include with your project.

Click on the Add Current… button to add our current scene to the game, as follows:

After that, since we are just publishing to our current platform, confirm that the settings are correct, and click on the Build and Run button.

Once you press the button, you'll be brought to a menu to name your application that you are going to save. Give it a name, save it, and wait. If all goes well, you should be brought to a menu allowing you to set some options before the game starts:

After that, click on the Play! button to see your completed project. Have a look at the following screenshot: