Unity 5.x Game Development Blueprints

With Unity started and the launcher, select New. Select a Name and a Project Location of your choice somewhere on your hard drive, and ensure that you have 2D set. Once completed, select Create project. At this point, we will not need to import any packages, as we'll be making everything from scratch. Have a look at the following screenshot:

From there, if you see the Welcome to Unity popup, 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 corner 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:

From the Project tab, double-click on the Sprites folder. Once inside, right-click within the Sprites folder and select Import New Asset to select the playerShip.png file from the Chapter 1/Art Assets folder from our example code to bring it in. Once added, confirm that the image's texture type is Sprite by clicking on it and from the Inspector tab, confirm that the Texture Type property is Sprite (2D and UI). 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 (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. However, instead of creating a huge image or copying and pasting a similar image over and over, we will learn how we can use a material with a repeating texture.

From the Project tab, bring the background sprite into the project and then select it and change the 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 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 pixilation, 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.

As we won't be using it (and we're a 2D game), remove the BoxCollider component by right clicking on it from the Inspector tab and then 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 BackgroundMaterial. We can create a new folder called Materials to store this, but since this project will only use one it is OK to stay in Sprites. 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:

You can also add a material to an object by dragging and dropping the material onto the object in the Scene tab.

Well, at this point we have a color, but we don't have the stars from our image repeating.. This is due to how the Wrap Mode property is set. In Unity 5.2, the default mode is Clamp, which means that the edges of the image will be extended out rather than repeat. Let's fix that now.

From the Project tab, select the background texture object. Once selected, go to the Inspector tab, change the Wrap Mode to Repeat, and then click on Apply. Finally, select the Cube object from Hierarchy and then in the Inspector tab at the top, rename the object to Background.

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 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 or Visual Studio Community 2015 depending on how you installed Unity and what OS your computer is running.

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 (and will possibly show up as red in your IDE because of that). Let's do that now!

Below the Update function and before the } that closes the class, 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;
}

In this code, we are changing the rotation of the object we attached this script to (our player) based on where the player has put the mouse. Now, if you comment out the Movement line (by putting // in front of it) 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:

If you did comment out the line, be sure to remove the // before continuing.

Below the Rotation function, we now need to add the following code in our Movement function:

// 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.x += Input.GetAxis ("Horizontal");
  movement.y += Input.GetAxis ("Vertical");

  /* 
    * 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, we use Unity's built in Input properties in order to set the x and y aspect of our movement vector and then move (or Translate) the ship in that direction. Edit | Project Settings | Input will open up Unity's Input Manager, which will have a list of different Axes that can be used for input.

As you can see here, left and a are used in the Negative Button and Alt Negative Button properties respectively, so if we press either of those two it will give you a number between -1 and 1, with positive giving you a value between 0 and 1.

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 on the top toolbar. And you should see something like 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;

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.

In our game, the player may want to shoot using either my clicking or the Space key. You may even want to use something else. Rather than restricting the player to just having one button or using an Axis like we did previously, we will store all of the possible ways to shoot in their own container. To do this, we are going to use a list, which is a holder for multiple objects that we can add or remove while the game is being played. However, to use a list, we will need to add the following to the top of our code:

using System.Collections.Generic; // List

Afterwards, add the following variable below the others:

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

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 this code 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()
{
  // We want to position the laser in relation to 
  // our player's location
  Vector3 laserPos = this.transform.position;
  // The angle the laser will move away from the center
  float rotationAngle = transform.localEulerAngles.z - 90;
  // Calculate the position right in front of the ship's
  // position laserDistance units away
  laserPos.x += (Mathf.Cos((rotationAngle) * 
               Mathf.Deg2Rad) * -laserDistance);
  laserPos.y += (Mathf.Sin((rotationAngle) * 
               Mathf.Deg2Rad) * -laserDistance);
  
  Instantiate(laser, laserPos, 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.

Now, change the Size of each of the Shoot Button variables to 2, and fill in the Element 0 value with Mouse0 and Element 1 with Space. When you've finished, it should look something like the following screenshot:

Next, we will need to create our laser to fill in the Laser variable. 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 your IDE, 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 2D 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 inside of it. To do that, we will change the Size attribute's X property to .09 and Y to .5. To see exactly what we're modifying, you can zoom in the camera by using the mouse wheel in the Scene tab:

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

To differentiate this object from the laser sprite that we used to create it, select your laser object in the Hierarchy tab and then under the Inspector change its name to Laser.

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, because we have the prefab created, we don't need the original in the scene because we'll be spawning them instead. With that in mind, delete the Laser object from our scene, and then go to the playerShip object. For clarity, rename it to Player Ship and then drag and drop the Laser prefab from the Project tab into the Laser property of the PlayerBehavior component.

Finally, we want our player to have collision as well, so let's add a circle collider to our ship by going to Component | Physics 2D | Circle Collider 2D. Change the Radius property to 0.3.

Leave the game by pressing the Play button again and then 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.

The GameObject.Find function is very useful as it allows us to access objects at any time, but is computationally expensive, so don't put it in a function that gets called often (such as Update) when you can just save a reference to it. It's also important to note that the spelling of the parameter has to be exactly the same as the object's name in the hierarchy; so be sure to double check when you use it.

Drag and drop this newly added behavior onto our enemy object and rename it to Enemy.

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 (your IDE of choice,), 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 when called will print something onto your console (in this case, name the object that we collided with), which may help you when debugging your own code in the future.

It's also important to note the reason we ask if the name contains Laser instead of is equal to is because when you create an object using Instantiate, by default it will add " (Clone)" to the end of the name of the object.

We also want to tell the objects to actually react to collision events so we will need to add Rigidbody 2D physics to the object, which is required one of the two objects involved in a collision in order for OnCollisionEnter2D to be called.

Select the Enemy object and then select Component | 2D Physics | Rigidbody 2D. From there, change the GravityScale value to 0 so that the object will not fall down by default due to gravity.

Save your script, and then go back into Unity. Attach the EnemyBehaviour behavior to your enemy object, save your project, and run the game. If all went well, we should have something like the following screenshot:

First, create an empty game object by going to Game Object | Create Empty. From there, with the object selected, go to Inspector and set its name to Game Controller, and optionally, for neatness sake, set its Position to (0, 0, 0). As this is our main game object, I'm also going to drag it up on the Hierarchy tab so that it is the top object on the list.

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

Next, let's see another way that we can create scripts quickly. From the Inspector tab, select Add Component | New Script, and once you are brought to the next menu, change the language to C#, and set the name of the script to GameController.

Select the newly created script, and move it to the Assets\Scripts folder. Go to your IDE of choice 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:

// 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:

[Header("Wave Properties")]
// 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;

Now, if we save the script and go back into the editor, you'll notice a couple of interesting things. First of all, you'll see that due to the Header that we added to our script, the script has been separated into sections to make it easier to compartmentalize our code. In addition, we also see a warning on the bottom-left of the screen saying that we haven't used our variables yet. You can click on it to open up the Console window to look at it, but with that in mind, let's make it so that we are actually using the variables.

We now need a function to spawn enemies; let's call it SpawnEnemies. We don't want to spawn all of 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 of 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 of the previous
    // wave's enemies are dead
    if(currentNumberOfEnemies <= 0) 
    {

      //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)
        float randDistance = Random.Range(10, 25);

        // Enemies can come from any direction
        Vector2 randDirection =
          Random.insideUnitCircle;
        Vector3 enemyPos =
          this.transform.position;

        // Using the distance and direction we set the 
        // position
        enemyPos.x += randDirection.x * randDistance;
        enemyPos.y += randDirection.y * 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, enemyPos, 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);
  }
}

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

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 lines:

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

The preceding line gets the script GameController from the game object that has the GameController tag.

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 | 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.

Click on the 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.

Go back to the top Explosion section and then change Simulation Space to World; that way, if this object moves, the already-spawned particles will not move. After this, still in the Explosion section, uncheck Looping.

At this point, you'll need to click on the Stop and Simulate buttons to see how the properties change while we make adjustments.

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 the Project tab, 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 OnCollisionEnter2D, 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);
}

As you can see here, we use the Instantiate function in order to create an explosion and we call the Destroy function to have it automatically delete itself (the first parameter) after 2 seconds as passed (the second parameter).

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.

From there, go into the Inspector and uncheck the Play On Awake property. Otherwise, if there is something attached to AudioClip it will play that sound automatically.An audio source lets the audio listener attached to the Main Camera object know that this is an object that can play sounds.

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 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
GetComponent<AudioSource>().PlayOneShot(hitSound);

In this instance, I used the GetComponent function to access the AudioSource component that is attached to the game object this is attached to. It is important to note that GetComponent is a fairly expensive function to call. Since this will only be used once, it's OK to use like this; but if you were to use this more than once, I would suggest creating an AudioSource variable and setting it in the Start function instead like we will be doing in the next section.

Now, we need some actual sounds to play. I've set aside a folder of assets for you in the Example Code folder, so open your project folder via your Explorer and move the folder into your project's Assets and then return to Unity.

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; however, make sure that the Play On Awake property is still checked. After this, set the Audio Clip property in the component to the explode sound.

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 check Play On Awake or 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.

Next, go into PlayerBehaviour, and add in two new variables, as follows:

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

// Reference to our AudioSource component
private AudioSource audioSource;

Then, we need to initialize the audio property, so add a Start function with the following:

  void Start()
  {
    audioSource = GetComponent<AudioSource>();
  }

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

audioSource.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. Change Audio Clip to bgm, check the Loop option, and set Volume to .25.

Save everything, and run the game!

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

You'll notice that three objects get created at this point: Canvas, Text, and Event System. Right now, we only need to worry about Text; however, the three objects are all needed in order for Unity's new UI system to function properly. We will be discussing this in much more detail in a later chapter.

Next, select the Text object again and notice that the top of it has a Rect Transform component instead of a Transform. This is a special transform that is used to position UI elements on the screen relative to other objects that are also part of the UI.

In this case, we want the text to be located in the top-left, but currently you may not be able to see the text at all. You can double-click on the object to zoom out and see it more clearly.

As you can see, the text is much larger than the player, and there seems to be a white box surrounding the object. This is a representation of what the UI will look like, with the white box being the screen. Rect Transform is currently set up to represent a position of (0,0) to be the center of the world and currently the text is -21 pixels away from the center in the x axis and -97 in the y. If we were to change it to (0,0), you'd notice that the text would now be centered.

Rename the Text object to Score Counter and then change the Anchors Min Max and Pivot properties to (0, 1); then reset Pos X to 10 and Pos Y to -10 to move them slightly away from the edge of the screen. Lastly, change the Color to white to make it easier to see.

Now that we have the text set up, let's set the font. Bring 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 Anchors Min Max and Pivot properties to (1, 1) and then reset Pos X to -10 and Pos Y to -10 to move them slightly away from the edge of the screen. Afterward, in the text component, change the Alignment to be right aligned horizontally.

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 will first need to let the script know to use Unity's new UI system:

using UnityEngine.UI;

Afterward, we need to create some new variables as follows:

  [Header("User Interface")]
  // The values we'll be printing
  private int score = 0;
  private int waveNumber = 0;
  
  // The actual GUI text objects
  public Text scoreText;
  public Text 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 of the variable and add something additional 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 opening { of the if(currentNumberOfEnemies <= 0) block, add the following lines:

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

Save all of the script files, go back to Inspector, and set the Score Text and Wave Text objects to the proper variables in the Game Controller object. After that, save your project and 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: