In-class review of relevant concepts around variables, operators and other basics (see slides for a summary)

• Variables

There are many different types of variables (or vars), and each will store only one specific type of data:

int: hold whole numbers, e.g. 0, 1, 2

floats: hold numbers with a decimal point, i.e. floating point numbers, such as 3.56, 1.23, which often have an f after them in Unity, e.g. 3.4f, to distinguish them from int vars when it's not clear, e.g. 2f.

string: hold a series of ASCII characters

bools: are either true or false;

You need to name vars properly, e.g. with meaningful names like myString, myHealth that follow camel case.

public variables are accessible by the entire script plus visible in the Unity Inspector, while private variables are only accessible within the script aka class and not visible in the Unity Inspector.

Declaring/setting variables
In Unity you declare variables by stating if it is public or private, stating its data type, then stating its name, e.g:

public int myHealth;

You can set a variables value when you declare it, e.g.:

public int myHealth = 6;

Or, if it is a public variables, you can set it in the Inspector when the script is attached to a GameObject. What you enter in the Inspector will override any assignment set when the variable is declared, but will be overriden if you subsequently set the variable in script, e.g.

myHealth = 10;

• Commenting code

You need to comment code to explain what it does, both for yourself and other people in a team: this is invaluable when you come back to old code and need to modify/extend it!

// for single lines

/* */ for multiple lines

• Random numbers

You often need to produce a random number within a specific range in games, to create probability (and simulate dice rolls, if it's an RPG!). You can create random int and float values within a minimum and maximum range:

• Random.Range (int)

public int myInt;

myInt = Random.Range(0,11)

This will give us a whole number between 0-10 .

• Random.Range (float)

public float myFloat;

myFloat = Random.Range(0f,10f)

This will give us a decimal number between 0.0-10.0 i.e. 6.75f. If we didn’t include the f in our min and max of the Random.Range, then it will only return a whole number i.e. 6.

• If statements / if else statements / if else if else statements

If statements check to see if certain statements are true, and use 'operators' to do so:

• • use < or > when checking if a variable is less than or greater than a value

  • use = when assigning variables a value

  • use == when comparing/checking a variable's value

  • use ! to check a variable is NOT a certain valuable

  • use && to set a condition whereby two or more conditions are true

if (health <= 0 && alive == false && !dying)

{

Debug.Log ("The character has died!");

}

• if else statements and if else if else statements are simply if statements with more control over a series of possible conditions, and highly useful for controlling the flow of actions: e.g. you might change the colour of a player's health bar to green, yellow, orange or red using an if else if else statement checking if the player's health is within specific ranges.

if (health > 90)
{
/*set health bar to green, e.g. referring to a UI element's color */
}
else if (health > 60)
{
// set health bar to yellow
}
else if (health > 30)
{
// set health bar to orange
}
else
{
// set health bar to red
}

In-class review of relevant concepts around functions (see slides for a summary)

• Scripts referencing other scripts

Scripts routinely need to interact with one another, e.g. when a door may need to check to see if a character trying to open it possesses the key in its inventory. Three common ways to do this are:

Creating a variable that refers to the script, and assign it in the inspector:

public ScriptName someScript;

During run-time, use GetComponent() to find a script of a specific type attached to a specific game object

GetComponent<ScriptName>() :

Using the Find function, to search child objects for a script of a specific type (this is slower, and not usually recommended):

FindObjectOfType<ScriptName>():

• Arrays:

Arrays are just variables that hold multiple variables. A simple example would be an array that indicates the status of players in a 4 player game (i.e. to see if they are playing/not playing the game each could have a bool called isPlaying that is true or false).

Arrays usually declared with a fixed length, and importantly when referring to items in an array they start at 0 and end at one LESS than the number in the array (e.g. array of 10 items is item 0 to 9)

Create an array

public string[] mySuperAwesomeArray;

public SomeClass[] mySuperAwesomeClassArray;

Set/Add item to array

myArray = new int[]{ 10, 5, 4, 6 }; // the {} lets us put some value inside our array.

Check item in array

myArray[0]; // This will access the value inside element 0 of my array i.e. 10.

Remove item from array by recreating it

myArray = new int[]{ 10, 4};

Get length of array

myArray.Length;

Get random element from an array

myArray[Random.Range(0, myArray.Length)];

• Lists

Lists are very similar to arrays, but are designed to be easy to add to/extend. A simple example would be a player's inventory, which would have items regularly added to or removed.

Create a list

myList = new List<DataType>(); :

Check item in list

myList[0]; // This will access the value inside element 0 of my list i.e. 10.

Add item to list

myList.add(6); // Will add 6 as a new element at the end of our list.Remove item from list

Get length of list

myList.Count;

Get random element

myList[Random.Range(0, myList.Count)];

• Out of range Errors

If you try to check an item that doesn't exist in a list or array, e.g. you try to check the name of a 10th item in a list that only contains 6 items, you will get an out of range error.

• looping through arrays/lists with for statements

for(int i=0; i<myArray.Length; i++)

{

// Does this action 3 times and logs out the number each time.

Debug.Log(i);

}

for(int i=0; i<myList.Count; i++)

{

// Does this action 3 times and logs out the number each time.

Debug.Log(i);

}

looping through arrys lists with foreach

foreach(int i in myIntArray)

{

Debug.Log(i);

}

while loops

Int i =0;

While( i > 4)

{

Debug.Log(“i win”);

}

• Object-oriented progamming (OOP)

Old programming used to just be one or more large 'god' scripts that stored references to objects and handled everything, e.g. Basic.

Object oriented programming has a compiler/editor that allows you to create virtual objects, like GameObjects, and add scripts to them. The scripts on these objects operate independently, making them less liable to inadvertently affect one another, but also can communicate.

Everything you have done in Unity scripting is object-oriented because you are using GameObjects!

• classes, composition, and inheritance

All scripts are classes, i.e. a collection of variables and instructions. By default all unity scripts inherit from class Monobehaviour, which is Unity's base class that includes functions like Update(), OnTriggerEnter() etc that you can use automatically.

However you can nest classes, e.g. create a class within a script, that holds its own variables and instructions.

You are using a 'composition' approach when a GameObject is powered up by adding scripts to it, e.g. a Character GameObject has move.cs , health.cs and fire.cs scripts attached, and this gives it the ability to move, take damage/die, and cause damage.

You are using an 'inheritance' approach when you create a class within a script and create a variable that 'inherit' its datatypes from that class, e.g. you create a class called 'car' with variables for its name, its GameObject, its health, its speed etc, then create a new variable of car that can have its own instances of these values.

public class car

{

string name;

GameObject chassis;

int health;

float speed;

}

public car corvette;

You also are using inheritence when you create a script that inherits an entire other scripts functions, e.g. you create script called CarMotor.cs with variables for the motor's properties plus functions to make the engine work, then create a new script called CorvetteEngine that (instead of inheriting from MonoBehaviour) inherits from CarMotor all its variables and functions, but also can add to them.

public class CorvetteEngine : CarMotor;

• Unity-specific functions

Since your Unity scripts 'inherit' from Monobehaviour by default, you have access to some specific unity scripting functions, e.g. regarding input, collisions, triggers.

Inputs

Input.GetKeyDown() - only checks once when the button is pressed down.

Input.GetKey() - Checks/Executes as long as the button is pressed.

Input.GetKeyUp() - only checks when the key is released.

Public KeyCode button;

if(Input.GetKeyDown(button))

{

// Do something

}

Collisions

OnCollisionEnter: When the collision occurs.

OnCollisionStay: When the collision keeps occuring.

OnCollisionExit: when we exit the collision.

void OnCollisionEnter(Collision col)

{

// Do something on collision.

}

Triggers

OnTriggerEnter: When the trigger is first passed in.

OnTriggerStay: When the object is still inside the trigger.

OnTriggerExit: when we exit the trigger.

void OnTriggerEnter(Collider other)

{

// Do something now something has passed into the collider.

}

'this' keyword:

This simply refers to the script that includes the this term

// an enemy could destroy itself by saying

Destroy (this.gameObject)