Introduction to Game Design, Prototyping, and Development (2015)

After following the Appendix A instructions to create a new project and saving your new scene as _Scene_0, use the Create menu in the Hierarchy pane to create a new sphere by selecting Create > Sphere, as shown in Figure 25.2.

Figure 25.2 Creating a sphere in _Scene_0

Select Sphere by clicking its name in the Hierarchy pane. Then set the position of the sphere to the origin [0, 0, 0] (that is, x=0, y=0, z=0) using the Transform component (highlighted with a red box in Figure 25.2).

In the Project pane, choose Create > C# Script and name the script Enemy. Double-click the script to open it in MonoDevelop, and enter the following code (identical to Figure 25.1). Lines that you need to add are bolded in the code listing.

1 using UnityEngine; // Required for Unity
2 using System.Collections; // Automatically included by Unity
3 using System.Collections.Generic; // Required if you want to use a List
4
5 public class Enemy : MonoBehaviour {
6
7 public float speed = 10f; // The speed in m/s
8 public float fireRate = 0.3f; // Shots/second (Unused)
9
10 // Update is called once per frame
11 void Update() {
12 Move();
13 }
14
15 public virtual void Move() {
16 Vector3 tempPos = pos;
17 tempPos.y -= speed * Time.deltaTime;
18 pos = tempPos;
19 }
20
21 void OnCollisionEnter( Collision coll ) {
22 GameObject other = coll.gameObject;
23 switch (other.tag) {
24 case "Hero":
25 // Currently not implemented, but this would destroy the hero
26 break;
27 case "HeroLaser":
28 // Destroy this Enemy
29 Destroy(this.gameObject);
30 break;
31 }
32 }
33
34 // This is a Property: A method that acts like a field
35 public Vector3 pos {
36 get {
37 return( this.transform.position );
38 }
39 set {
40 this.transform.position = value;
41 }
42 }
43 }

Most of this should look pretty straightforward and familiar to you except for the property and the virtual function. Both are covered in this chapter.

Properties

You can see in the previous code listing that the property pos is treated as if it were a variable in both lines 16 and 18 of Move(). This is accomplished through the use of the get{} and set{} accessor clauses, which enable you to run code each time you read or set a property. Every time the pos property is read, the code within the get{} accessor is run, and the get{} accessor must return a value of the same type as the property (that is, Vector3). Code within set{} is run every time the pos property is assigned a value, and the value keyword is used as an implicit variable that holds the value assigned. In other words, in line 18, pos is assigned the value of tempPos; then in line 40, the value of tempPos is held by the variable value and assigned to this.transform.position. An implicit variable is one that exists without you, the programmer, explicitly declaring it. All set{} clauses in properties have the implicit variable value. It is possible to create a property with only a get{} accessor (or only a set{} accessor) to make the property read-only (or write-only).

In the pos property example, pos is used simply to access the field this.transform.position with less typing. However, the following code listing holds a more interesting example. Create a new C# script named CountItHigher, attach it to the sphere in the scene, and enter the following code:

1 using UnityEngine;
2 using System.Collections;
3
4 class CountItHigher : MonoBehaviour {
5 [SerializeField]
6 private int _num = 0; // 1
7
8 void Update() {
9 print( nextNum );
10 }
11
12 public int nextNum { // 2
13 get {
14 _num++; // Increase the value of _num by 1
15 return( _num ); // Return the new value of _num
16 }
17 }
18
19 public int currentNum { // 3
20 get { return( _num ); } // 4
21 set { _num = value; } // 4
22 }
23
24 }

1. The integer _num is private, so it can only be accessed by this instance of the CountItHigher class. Other classes and class instances can’t see it at all. The [SerializeField] attribute on the previous line allows this private variable to be seen and edited in the Inspector.

2. nextNum is a property that is read-only. Because there is no set{} clause, it can only be read (e.g., int x = nextNum;) and cannot be set (e.g., nextNum = 5; would cause an error).

3. currentNum is a property that can either be read or set. Both int x = currentNum; and currentNum = 5; would work.

4. The get{} and set{} clauses can alternatively be written on a single line. Note that when in the single-line format, the semicolon ending the statement (;) comes before the closing brace (}) as shown on line 21.

When you press Play, you will see that as the Update() function is called by Unity each frame, the output of the print( nextNum ); statement increments every frame. The output from the first five frames is as follows:

1
2
3
4
5

Each time that the property nextNum is read (by print( nextNum );), it increments the private field _num and then returns the new value (lines 14 and 15 of the code listing). Though this is a small example, it’s possible to use a get or set accessor to do anything that a regular method can do, even call another method or function.

Similarly, currentNum is a property that enables you to either read or set the value of _num. Because _num is a private field, it is helpful to have the property currentNum publicly available.

Class Instances are GameObject Components

As you’ve seen in previous chapters, when you drag a C# script onto a GameObject, it becomes a component of that GameObject just as Transform, Rigidbody, and other elements that you see in the Unity Inspector are GameObject components. This means that you can get a reference to any class that is attached to a GameObject via GameObject.GetComponent<>() with the type of the class placed between the angle brackets (see line 7 of the following code listing).

Create a new C# script named MoveAlong and attach it to the same Sphere GameObject as CountItHigher. Enter the following code into the MoveAlong script:

1 using UnityEngine;
2 using System.Collections;
3
4 class MoveAlong : MonoBehaviour {
5
6 void LateUpdate() { // 1
7 CountItHigher cih=this.gameObject.GetComponent<CountItHigher>(); // 2
8 if ( cih != null ) { // 3
9 float tX = cih.currentNum/10f; // 4
10 Vector3 tempLoc = pos; // 5
11 tempLoc.x = tX;
12 pos = tempLoc;
13 }
14 }
15
16 public Vector3 pos { // 6
17 get { return( this.transform.position ); }
18 set { this.transform.position = value; }
19 }
20
21 }

1. LateUpdate() is another built-in function call that Unity makes every frame. Each frame, Unity first calls Update() on all classes that are attached to GameObjects and then, once all the Update()s are complete, Unity calls LateUpdate() on all objects. UsingLateUpdate() here ensures that Update() in the CountItHigher class is called before LateUpdate() in the MoveAlong class.

2. cih is a local variable of the type CountItHigher, meaning that it can hold a reference to the instance of CountItHigher that is a component attached to the Sphere GameObject. The GetComponent<CountItHigher>() call finds the CountItHigher (Script) component attached to the same Sphere GameObject as this MoveAlong (Script) component.

3. If you use the GetComponent<>() method, and the type of component you ask for is not attached to the GameObject, GetComponent<>() will return null (a value that means nothing is there). It is important to check for this before trying to use cih.

4. Although cih.currentNum is an int, when it is used in a mathematical operation with a float (e.g., cih.currentNum/10f) or assigned to a float (which also occurs on line 9), it is automatically treated as a float.

5. Line 10 and 12 use the pos property that is defined in lines 16-19.

6. This is effectively the same as the pos property of the Enemy class, but it uses a single line to define each of the get{} and set{} clauses.

Every LateUpdate, this code will find the CountItHigher script component of this GameObject and then pull the currentNum from it. The script then divides currentNum by 10 and sets the x position of the GameObject to the resultant value (using the pos property). AsCountItHigher._num increases every frame, the GameObject will also move along the X axis. Press Play in Unity to see this happen. Save your scene (from the menu bar, choose File > Save Scene) before continuing in the chapter.