Setting up our Player, PlayerSpawner, and PlayerBullet scripts

Now that we are familiar with the Player script's relation to the other scripts, we can start coding it:

1. In the Project window of the Unity editor, create a script in the Assets/Resources/Scripts folder with the filename Player.
2. Open the script and add the IActorTemplate interface to the existing default code:

using UnityEngine;

 public class Player : MonoBehaviour, IActorTemplate
 {

The script will by default create a UnityEngine library (including some others), the name of the class, and MonoBehaviour. All of these are essential to make the script work in the Unity editor.

3. Continuing with the Player script, enter the following global variables:

    int travelSpeed;
    int health;
    int hitPower;
    GameObject actor;
    GameObject fire;    

    public int Health
    {
        get {return health;}
        set {health = value;}
    }

    public GameObject Fire
    {
        get {return fire;}
        set {fire = value;}
    }

    GameObject _Player;

    float width;
    float height;

We have entered a mixture of integers, floats, and game objects in our global variables; starting from the top, the first six variables will be updated from the player's SOActorModel script. travelSpeed is the speed of the player's ship, health is how many hits the player can take before dying, hitPower is the damage the ship would cause when colliding into something that could receive damage (the enemy), actor is the three-dimensional model used to represent the player, and finally, the fire variable is the three-dimensional model of which the player fires. If that seemed a little rushed, check the Introducing our ScriptableObject – SOActorModelsection, where we go into more detail about these variables.

The two public properties of Health and Fire are there to give access to our two private health and fire variables from other classes that require access.

The _Player variable will be used as a reference to the _Player game object in the scene.

The last two variables of width and height will be used to store the measured results of the world space dimensions of the screen the game is played in. We will discuss these two more in the next block of code.

While we are on the approach to the Start function code block next, some may question why we would pick Start over Awake when it comes to running a function's code content. Both functions run once at runtime; the only noticeable difference is that Awake runs before Start with regards to Unity's execution order, as can be seen in the documentation at https://docs.unity3d.com/Manual/ExecutionOrder.html.

For simplicity in our Unity project, we will vary between which of the two functions to use. This is so we avoid conflicts between several Awake functions running at the same time. As an example, one script may try to update its Text UI, but the variable updating the text may still be null at runtime because the script with the variable is still waiting for its content to be updated.

There is a way around to avoid conflicts between several Awake functions being called by several scripts at runtime by going to Unity's Script Execution Order in Edit | Project Settings | Script Execution Order.

If you would like to know more about the Script Execution Order, check the documentation at https://docs.unity3d.com/Manual/class-MonoManager.html.

4. Continuing on with entering code into the Player script, next up, we will type out the Start function along with its content:

 void Start()
 {
   height = 1/(Camera.main.WorldToViewportPoint (new
      Vector3(1,1,0)).y - .5f);
   width = 1/(Camera.main.WorldToViewportPoint(new Vector3(1,1,0))
      .x - .5f);

   _Player = GameObject.Find("_Player");
 }

As previously mentioned, the height and width variables will store our world space measurements. These are required so that we can clamp the player's ship inside the screen. Both the height and width lines of code use similar methods, the only difference is with the axis we are reading.

The Camera.maincomponent refers to the camera in our scene and the function it uses, WorldToViewportPoint, is to take the results from the game's three-dimensional world space and convert the results into viewport space. If you aren't sure what viewport space is, it's similar to what we know as a screen resolution, except its measurements, are in points and not pixels, and these points are measured from 0 to 1. The following diagram shows the comparison between screen and viewport measurements:

So, with viewports, no matter what the screens resolution is, the full height and width are 1 and everything between that is a fraction. So, for the height, we feed Vector3 to WorldToViewportPoint, where Vector3 represents a world space value followed by -0.5f, which sets its offset back to 0. Then we divide 1 (which is our full-screen size) by the result of our formula. This will give us our current world space height of the screen. We then apply the same principles for the width and use x instead of y and store the result.

Finally, the last line of code takes the reference of the _Player game object in the scene and stores it into our variable.

5. Continuing on with the Player script, we have our Update function that is called on every frame. Enter the function along with the following two methods:

 void Update ()
 {
     Movement();
     Attack();
 }

The Update function runs the Movement method and Attack method every frame. We will go into depth about these two methods later on in the chapter.

The next method we are going to put into our Player script is the ActorStats method. This method is a requirement as we declare it in the interface we are inheriting.

6. Just after the scope of our Update function, enter the following piece of code:

public void ActorStats(SOActorModel actorModel)
 {
     health = actorModel.health;
     travelSpeed = actorModel.speed;
     hitPower = actorModel.hitPower;
     fire = actorModel.actorsBullets;
 }

The code we have just entered assigns values from the player's SOActorModelScriptableObject asset we made earlier on in the chapter.

This method doesn't get run in our script but gets accessed by other classes, the reason being these variables hold values regarding our player and don't need to be anywhere else.

7. Save the Player script.

Before we test what we have so far we need to attach our Player script to our player_ship in the Project window.

8. In the Project window, navigate to Assets/Resources/Prefab and select the player_ship prefab.
9. Select the Add Component button in the Inspector window. Type Player until the script appears and then select it.

With ourHierarchywindow containing the_Player, PlayerSpawnerand theGameManager game objects. We can see the player ship get created in ourGamewindow by pressingPlayin the Editor.

The followingscreenshotshows our game inPlaymode; note theHierarchywindow on the left with thePlayerSpawner game object as the parent of thePlayergame object; also note theGamewindow with its black background, and in the center, the player's ship is facing right and is located in the center of the screen. Finally, the far-right image showing ourScene window with ourPlayerSpawnericon:

Let's move on to the next section where we'll continue to work on the Player script, but this time we will look at what happens when our player's game object comes in to contact with an enemy.

Colliding with an enemy – OnTriggerEnter

In this section, we are going to add a function to our Player script that will check to see what has collided with our player's game object during runtime. Currently, the only thing that can collide with our player is an enemy, but we can still demonstrate the use of Unity's own OnTriggerEnter function, which handles most of the work for us:

1. Continuing on after the scope of our last method (ActorStats) in the Player script, we are going to add the following code that detects our enemy colliding with the player's ship:

  void OnTriggerEnter(Collider other)
  {
    if (other.tag == "Enemy")
    {
      if (health >= 1)
      {
       if (transform.Find("energy +1(Clone)"))
        {
         Destroy(transform.Find("energy +1(Clone)").gameObject);
         health -= other.GetComponent<IActorTemplate>
           ().SendDamage();
        }
        else
        {
            health -= 1;
        }
      }

      if (health <= 0)
      {
        Die();
      }
    }
  }

Let's explain some of the code we have just entered into the Player script.

OnTriggerEnter(Collider other) is a function that Unity recognizes to check what has entered into the player's trigger collider.

We use an if statement to check whether the tag to the collider is called Enemy. Note when we create our enemy, we will give them an Enemytag so they are easily identified. If the tag does equal to Enemy, we drop into that if statement.

The next if statement checks to see whether our player's health is equal to or more than 1. If it is, that means the player can take a hit and continue without dying and also means we can go into its if statement.

We approach the third if statement that checks to see whether the collider has a game object named energy +1(Clone). The name of this object is the name of the shield the player can purchase in the game shop which we will add in Chapter 6, Purchasing In-Game Items and Advertisements. If the player has this energy +1(Clone) object, we can Destroy it with Unity's premade function. We also deduct the player's extra health from the enemies' SendDamage function. We will discuss SendDamage later on in the chapter.

Following after the third if statement is an else condition where, in the event that the player doesn't have an energy +1(Clone) game object, the player gets their health deducted.

Finally, if the player's health is at a value of zero or under, we run the Die method, which we will cover later in the chapter.

Let's continue on with our Player script and add the functionality so the player can receive and send damage from and to the enemy.

In the next method, we are going to add two methods. The first method (TakeDamage) will take an integer called incomingDamage and use whatever the value is to deduct from our player's health value.

The second method (SendDamage) will return an integer of our hitPower value.

2. Just below and outside of the scope of our ActorStats method, now add the following code:

public void TakeDamage(int incomingDamage)
{
health -= incomingDamage;
}

public int SendDamage()
{
return hitPower;
}

Let's continue with another method for the Player script and make it possible so the player can control the player ship around the Game window.

The Movement method

In this section, we will code the Movement method, which will take input from the player's joypad/keyboard and also make use of the height and width floats to keep the player's ship within the screen.

1. Still in the Player script, make a start with the following method using the following content to check for the player's input:

void Movement()
{
  if (Input.GetAxisRaw("Horizontal") > 0)
  {
     if (transform.localPosition.x < width + width/0.9f)
     {
       transform.localPosition += new Vector3
          (Input.GetAxisRaw("Horizontal")
            *Time.deltaTime*travelSpeed,0,0);                                                                                                                            
     }
  }

The Movement method will consist of detecting movement in four directions being made from the player; we'll start with when the player presses right on the controller/keyboard. We run an if statement that checks whether the Input Manager has detected any movement from the Horizontal property. If the GetAxisRaw detects a value higher than zero, we fall into the if statement's condition. Note that GetAxisRaw has no smoothing so the player's ship will instantly move unless extra code is added.

Next, we have another if statement, this checks whether the player has exceeded past the width (that is, of the screen's world space that we calculated earlier on in the chapter). We've also added an extra partial width to avoid the geometry of the player's ship leaving the screen. If the player's position is still under the width (and its buffer) value, we run the content inside the if statement.

The player's position is updated with a Vector3 struct, which holds the value of the Horizontal direction, multiplied by time per frame, multiplied by the travelSpeed we set from our ScriptableObject.

2. Let's continue in the Movement method and add a similar if statement for moving the player ship to the left:

if (Input.GetAxisRaw("Horizontal") < 0)
   {
     if (transform.localPosition.x > width + width/6)
     {
      transform.localPosition += new Vector3
        (Input.GetAxisRaw("Horizontal")
          *Time.deltaTime*travelSpeed,0,0);                                                                       
     }
   } 

As we can see, the code is close to the previous block; the only difference is that our first if statement checks whether we are moving left; the second if statement checks if the player's position is greater than the width and a slightly different buffer.

Apart from that, the if statement and its content serves the same position, just in the opposite direction.

3. Let's continue with our Movement method and add the if statement code for moving the player's ship down:

if (Input.GetAxisRaw("Vertical") < 0)
{
    if (transform.localPosition.y > -height/3f)
    {
     transform.localPosition += new Vector3
      (0,Input.GetAxisRaw("Vertical")*Time.deltaTime*travelSpeed,0);
    }
}

Yet again, we follow the same rule from the previous two if statements, but this time, instead of Horizontal, we add the Verticalstring property. In the second if statement, we check whether the player's y-axis is higher than a negative height/3. The reason why we divide by this value is that later on in the book (Chapter 9, Creating a 2D Shop Interface and In-Game HUD) we will be adding graphics at the bottom of the screen that will restrict the players view.

4. Let's move on to the last if statement in the Movement method, up:

if (Input.GetAxisRaw("Vertical") > 0)
   {
    if (transform.localPosition.y < height/2.5f)
   {
    transform.localPosition += new Vector3
      (0,Input.GetAxisRaw("Vertical")*Time.deltaTime*travelSpeed,0);
   }
  }
}

As before, this if statement carries a similar role, but this time it's checking whether the player's position is under the height/2.5f value. A buffer is applied to stop the three-dimensional geometry from leaving the top of the screen.

5. Don't forget to save the script.

We will continue on with the Player script by adding the Die method.

The Die method

Adding the Die method to the Player script will make it so our player can be destroyed. Currently, inside the Die method is a Unity function called Destroy; this function will delete whatever game object is within its parameter.

Enter the following method in the Player script to destroy the player:

public void Die()
 {
     Destroy(this.gameObject);
 }

Let's move on to the last method in the Player script, which is to attack.

The Attack method

In this section, we will add the content to theAttackmethod in thePlayerscript.

The purpose of thisAttackmethod is to receive input from the player, create a bullet, point the bullet in the correct direction, and make the bullet a child of the Player game object to keep our Hierarchy window tidy.

Enter the following Attack method into the Player script to allow the player to fire bullets:

public void Attack()
 {
  if (Input.GetButtonDown("Fire1"))
    {
        GameObject bullet = GameObject.Instantiate
           (fire,transform.position,Quaternion.Euler
             (new Vector3(0, 0, 0))) as GameObject;
        bullet.transform.SetParent(_Player.transform);
        bullet.transform.localScale = new Vector3(7,7,7);
    }
  }
}

Inside the Attack method, we call an if statement that checks whether the player has pressed the Fire1 button (Left Ctrl on Windows; command if you are using a Mac). If the player has pressed the Fire1 button, we will drop into the if statement's scope.

Within theifstatement, we make anotherifstatement to make sure that when clicking the mouse, we are clicking on the screen and not anything UI related. This will become more relevant when we look at adding a Pause button in Chapter 10, Pausing the Game, Altering Sound, and a Mock Test. If we do click something UI related we callreturn, which means we exit theifstatement so that we don't fire a shot.

Next, we Instantiate our PlayerBullet game object from its instance name fire. We also face thefiregame object to the right, relative to the screen, and move it toward oncoming enemies. We store the results of creating and orienting our game object in a variable namedbullet.

We then set the size of the bullet to be seven times larger than its original size, which makes it look bigger.

Finally, within theifstatement, we make our bullet game object sit within a single game object with the variable name_Player.

That is all of the code required for the Player script! Make sure to save the script before moving on.

In the next section, we are going to move on to a different player script that controls what happens when the player fires their bullet.

Setting up our PlayerBullet script

In this section, we will be creating a bullet that will travel across the screen from the player's ship.

You will notice how similar thePlayerBulletscript is to thePlayerscript because it carries theIActorTemplateandSOActorModelscripts, which are already coded into thePlayerscript.

Let's create ourPlayerBulletscript:

1. In the Project window of the Unity editor, create a script in the Assets/Resources/Scripts folder with the filename PlayerBullet.
2. Open the script and check/enter the following code at the top of the script:

          using UnityEngine;
        

By default, we require the UnityEngine library to give the script functionality.

3. Let's continue by checking the correct class name and entering the following inheritance:

          public class PlayerBullet : MonoBehaviour, IActorTemplate {
        

We declare the public class and by default inherit MonoBehaviour. We also inherit the IActorTemplate interface to give our game object-related methods from the other game object scripts, such as SendDamage, and TakeDamage.

4. Enter the following global variables into the PlayerBullet script:

GameObject actor;
int hitPower;
int health;
int travelSpeed;

[SerializeField]
SOActorModel bulletModel;

All the variables we add are private. The last variable has a SerializeField attribute added. SerializeField makes it possible for this variable to be visible in the Inspector window, so even though it's private, we can still drag and drop assets into its field (which we will do shortly). More information on the SerializeField attributes can be found at https://docs.unity3d.com/ScriptReference/SerializeField.html.

5. Next, we'll move on and enter the Awake function along with its content:

void Awake()
 {
     ActorStats(bulletModel);
 }

In our Awakefunction is theActorStats method, which is a requirement because we are inheriting an interface that declares it.

6. Continue by entering the SendDamage and TakeDamage methods:

 public int SendDamage()
 {
   return hitPower;
 }

 public void TakeDamage(int incomingDamage)
 {
   health -= incomingDamage;
 }

As mentioned already in this chapter, we require these methods to send and receive damage.

7. Moving on, we enter the Die method along with its content:

 public void Die()
 {
     Destroy(this.gameObject);
 }

Another method to include from our interface is the Die method.

8. Next, enter the ActorStats method:

 public void ActorStats(SOActorModel actorModel)
 {
   hitPower = actorModel.hitPower;
   health = actorModel.health;
   travelSpeed = actorModel.speed;
   actor = actorModel.actor;
 }

The last method that we inherit from our interface is the ActorStats method, which will hold our ScriptableObject asset. This asset will then be assigned to our PlayerBullet script's global variables.

9. The next function is the OnTriggerEnter along with its if statement condition checks, as follows:

void OnTriggerEnter(Collider other)
 {
 if (other.tag == "Enemy")
 {
     if(other.GetComponent<IActorTemplate>() != null)
     {
         if (health >= 1)
         {
             health -= other.GetComponent<IActorTemplate>
               ().SendDamage();
         }
         if (health <= 0)
         {
             Die();
         }
     }
  }
 }

In the previous block of code, we run a check to see if our bullet has collided with an "Enemy" tagged collider. If the collider is tagged as "Enemy" to the player, we then check to see whether the collider holds an IActorTemplate interface. If it doesn't then it's likely the "Enemy" collider could be an obstacle. Otherwise, we deduct health from the Enemy game object and check to see if it's dead.

10. Now, let's enter Unity's Update function for the bullet's movement:

void Update ()
 {
   transform.position += new
      Vector3(travelSpeed,0,0)*Time.deltaTime;
 }

The Update function adds to its x-axis each frame based on its travelSpeed value multiplied by Time.deltaTime (Time.deltaTime is the time in seconds from the last frame).

11. Next, enter Unity's OnBecameInvisible function:

    void OnBecameInvisible() 
    {
      Destroy(gameObject);
    }
}

This last function will remove any unnecessary bullets that have left the screen. This will help the performance of our game and keep it tidy. Make sure to have saved the script before continuing.

Next, we need to apply the PlayerBullet script to our Player_Bullet prefab:

1. Navigate to Assets/Resources/Prefab/Player and select Player_Bullet.
2. With Player_Bulletselected, click theAdd Componentbutton in theInspectorwindow and typePlayerBulletuntil you see the PlayerBulletscript.
3. Select the script and add the PlayerBullet asset to it from the Bullet Model field (drag the asset into the field or click the remote button to the right of its field).

The following screenshot shows our Player_Bullet with its script and asset:

We can now move on to the next section about making enemies for the player to attack!