Tutorial 0: Unity and C# scripts - basics

Introduction:

I will be honest, I am not the best programmer. It can be sometimes wrong, if I am trying to explain something about C# scripts. Here I will talk about basics of C# scripts in Unity3D.

C# is an simple programming language. Ok, it's not so easy. It's easy to learn, hard to master language. But you can do good games with only basic knowlege about C#. C# is an object-oriented programming language. This will help to manage your game. Instead of making one big and hard to understand script, you can make some small objects, wich can communicate together. The objects will be like building block, with them you can build your game. There is class in C#, wich is a template for an object (in C# you can define class with line class Name {};). It is easy to define class in Unity. You should create new C# Script and name it. Now yow will have one class which name is similar as script name. You can use this script as component for Unity gameobjects.

Little example:

As example you will make an easy space shooter game. Something like next picture:

In Unity editor this will be the scene with many gameobjects: background, stars, camera, enemy, asteroid, player... Every object in your game is a GameObject. And the GameObjects are builded from Components. Some components are predefined in Unity and are ready to use. As example: Transform (working with GameObjects world position), Sprite Renderer (you can see your sprite in the game world), UI Text (shows text in interface) and many other components. And C# scripts will be components in Unity, which can be connected to the GameObjects. The C# scripts can access on other components.

How we can use C# scripts ?

At first we can create empty GameObject in scene. A gameObject will be created. This GameObject will already have the Transform component (every GameObject in Unity has Transform component). The created GameObject does not have a rendering component, so we can not see them in the game. We should add another component Sprite Renderer. And set our asteroid image as rendered sprite. So we can can see the asteroid in the game.

And now we can make a C# script for our asteroid.

Again, it is not game tutorial. Just let us talk about C# scripts.

We should create new C# script and name it (something like "Moving", because we will move our asteroid). If we open the created script, we will see next template:

using UnityEngine;
using System.Collections;

public class Moving : MonoBehaviour {

// Use this for initialisation
void Start () {
}

//Update is called once per frame
void Update () {
}
}

Little explain about lines:

Using UnityEngine;	With this line we can access on UnityEngine namespace. Namespace in C# is collection of classes (something like a library).
using System.Collections;	Here we can access on Microsoft .NET namespace.
public class Moving : MonoBehaviour {	public means, that we can access on our class from other class. class Moving is our classes name. MonoBehaviour is the base class, we need them for many functions (like "Update", "Start"). Check Unity Documentation for details.
// Use this for initialization	This line is just comment. It isn't important for C#.
void Start () {}	void means, that our function return no values. Start () {} this function will be executed once at scene start.
void Update () {}	This function will be executed every frame.

Now we will put our asteroid in the middle of the game world. The gameobjects position will be defined in Transform component (every GameObject has the transform component). We should add our Moving script to the asteroid. From our script we can change variables in transform component, which controls gameobjects position.

We will put our asteroid in the middle of the game world only once at game start.

Basically, if you will access on other component, you should do next steps:

1. Find other GameObject: and reference it: there are different ways to achive that.
- You can use GameObject.Find ("Name") / GameObject.FindWithTag ("Tag")
- make reference from editor with public GameObject;.
- You can get the GameObject from one Unity function like (Trigger, Raycast,...).
- Don't forget, you don't need to search for GameObject, if your script is on the same GameObject .

2. Get its Component with gameobject.GetComponent < ComponentName > (); or GetComponent < ComponentName > (); if on the same GameObject.

Transform component:

There is an easy way to access on the Transform component, if the component (our script) is on the same GameObject. Just type transform. in the script (be careful, this is working only with own Transform component. You should use GetComponent for all other components).

Position in the game world is Vector (x,y,z). If we will put asteroid in the zero point, we should change this vector to (0,0,0). C# line will be:
transform.position = new Vector3 (0, 0, 0);
We will do this only once at start, we should put this line in void Start () {}. And our script will be:

If game is started now, our asteroid will be teleported to zero in the world.
Look again at the Transform component:

Use transform. to access on Transform component on the same GameObject. And then you can change Position, Rotation, Scale (example: transform.localScale = new Vector3 (0.5F, 1, 1);). Your IDE will help you by typing, and you can see what you can change.

Don't forget you can get the values from other component too.

Let us now work with an other component. We have a Sprite Renderer connected to the asteroid.
spriteRenderer component screenshot

Now we will flip once at start the sprite on y-axe. We don't need to find GameObject (because our script is on the same GameObject). We can change Y-flip-variable direct with GetComponent < ComponentName > ().. For component name just check the GameObject Inspector (the name will be without spaces). The C# line will be:
GetComponent < SpriteRenderer > ().flipY = true;
And the script will be:

using UnityEngine;
using System.Collections;

public class Moving : MonoBehaviour {

// Use this for initialisation
void Start () {
//change gameobjects position
transform.position = new Vector3 (0, 0, 0);
//access to renderer component and change boolean variable, which controlls Y-flip
GetComponent < SpriteRenderer > ().flipY = true;
}

//Update is called once per frame
void Update () {
}
}

Again, your IDE will try to show the posible options.

Sometimes, if you are working much with other component, you should make reference to it (like link). You should define the variable, which has the typ as linked component (just name from linked component). Then reference it to other component with GetComponent < ComponentName > (). And later you can use this reference variable.

using UnityEngine;
using System.Collections;

public class Moving : MonoBehaviour {

//declare reference variable for renderer component
SpriteRenderer sr;

// Use this for initialisation
void Start () {
//change gameobjects position
transform.position = new Vector3 (0, 0, 0);
//reference to renderer
sr = GetComponent < SpriteRenderer > ();
//change boolean variable, which controlls Y-flip
sr.flipY = true;
}

//Update is called once per frame
void Update () {
}
}

And we can access to component on an other GameObject.
At first we need reference to other GameObject. As said, there are many ways to access on other GameObject. As example, we have other GameObject in scene. Its name is Ship and its tag is Player (Tags are used for GameObjects identfication).

1. If GameObject is in the scene at the game start, we can define public variable playerShip (typ GameObject) in the asteroids Moving script and assign the ship to the variable (just drag&drop GameObject on variables field in inspector). Now we can access on Ships components from our asteroids script. As example, we will place the ship on position (1, 1, 0) in the world at game start. The C# line whould be:
playerShip.transform.position = new Vector3 (1, 1, 0);

using UnityEngine;
using System.Collections;

public class Moving : MonoBehaviour {

//declare reference variable for renderer component
SpriteRenderer sr;
//public reference variable for players ship
public GameObject playerShip;

// Use this for initialisation
void Start () {
//change gameobjects position
transform.position = new Vector3 (0, 0, 0);
//reference to renderer
sr = GetComponent < SpriteRenderer > ();
//change boolean variable, which controlls Y-flip
sr.flipY = true;
//get access to players transform component and change its position
playerShip.transform.position = new Vector3 (1, 1, 0);
}

//Update is called once per frame
void Update () {
}
}

2. We can find other GameObject in scene and assign it to our varible with GameObject.Find ("Name") or GameObject.FindWithTag ("Tag"). C# line whould be:
playerShip = GameObject.Find("Ship");
or:
playerShip = GameObject.FindWithTag("Player");
Find with tag is more efficient as find with name. And our script whould be:

using UnityEngine;
using System.Collections;

public class Moving : MonoBehaviour {

//declare reference variable for renderer component
SpriteRenderer sr;
//public reference variable for players ship
public GameObject playerShip;

// Use this for initialisation
void Start () {
//change gameobjects position
transform.position = new Vector3 (0, 0, 0);
//reference to renderer
sr = GetComponent < SpriteRenderer > ();
//change boolean variable, which controlls Y-flip
sr.flipY = true;
//searching for players ship in scene and reference it
playerShip = GameObject.FindWithTag("Player");
//get access to players transform component and change its position
playerShip.transform.position = new Vector3 (1, 1, 0);
}

//Update is called once per frame
void Update () {
}
}

And don't forget: use GetComponent < ComponentName > ();, if you will access on different component as Transform. As example, if you will flip ships sprite on X-axe from asteroid script, the line whould be:
playerShip.GetComponent < SpriteRenderer > ().flipX = true;

using UnityEngine;
using System.Collections;

public class Moving : MonoBehaviour {

//declare reference variable for renderer component
SpriteRenderer sr;
//public reference variable for players ship
public GameObject playerShip;

// Use this for initialisation
void Start () {
//change gameobjects position
transform.position = new Vector3 (0, 0, 0);
//reference to renderer
sr = GetComponent < SpriteRenderer > ();
//change boolean variable, which controlls Y-flip
sr.flipY = true;
//searching for players ship in scene and reference it
playerShip = GameObject.FindWithTag("Player");
//get access to players transform component and change its position
playerShip.transform.position = new Vector3 (1, 1, 0);
//take players ship variable, access to its renderer component and change boolean variable, which controlls X-flip
playerShip.GetComponent < SpriteRenderer > ().flipX = true;
}

//Update is called once per frame
void Update () {
}
}

3. We can get our GameObject as return value from different Unity functions. I will explain some of them later in tutorials (as example: OnTriggerEnter2D (Collider2D otherCollider) {} Then we can get GameObject from otherCollider variable).

As you can see, creating a game in Unity is just working with variables in the components of gameobjects (I am not talking about creating music, models, texts ... It is a completely different story). Now we can take a look at the basics of C # scripts. The description will be short and will affect only the basic parts. You can google for details or ask in the forums.

C# scripts - basics:

1. Variables:

Variables are named memory areas that store different information. You will work with variables, it is better to know their main types:

Spoiler int:
This type of variables can take the value of an integer number. The variable lies in the range from -2,147,483,648 to 2,147,483,647. It is usually used to count the number of objects or cycles/arrays index. int score;
int healthPoint = 5;
float:
This type is for floating-point numbers (fractional numbers). The variable lies in the range from -3.4 × 10 ^ 38 to +3.4 × 10 ^ 38. It is usually used where the fractional part is important (for example, the distance to the target). float speed;
float distanceToShoot = 10.5;
bool:
This is a type of variable that has only two values true / false. Used in checking conditions (conditional statements). bool isDead;
bool canMove = false;
char:
Type of variables for Unicode characters. For example, separate letters. char litera;
char firstLitera = 'A';
string:
Type of variables for the character sequence/text (in fact it is a reference variable, it stores a reference to the memory area where this character sequence is located, but its operating principle is similar to value variables). The string class contains several functions. One of them is string.Length, which allows you to find the number of characters in the string. string newText;
string enemyText = "Stop! Don't move";
//example of using: string.Length
int howManyLetters = enemyText.Length; Vector3:
I put Vector3 into value variables, but in fact it is a structure. Structures are quite similar to classes, but unlike a class with values of structure it is possible to work directly with their values, and not through a link. Therefore, they are partly similar to variables. Arithmetic operations are possible. Vector3 structure contains few functions for working with vectors. Check Unity Documentation for details. When initializing Vector3, you must create a new instance using new or use an existing Vector3 (copy will be created). It is often used to determine the position of objects or their speed and movements direction. Vector3 move;
Vector3 enemyPos = new Vector3 (1, 1, 0);
//length of the vector
float vectorLength = enemyPos.magnitude; There are some other vectors. For example, Vector2 or Vector4, but the principle of their work is not different (except for multidimensionality). var:
This keyword is used to declare a variable without the type designation. The type of the variable will be defined later in the context of the program. var summe;
float a = 1;
float b = 1;
//variable summe will be float
summe = a + b;

2. Reference variables:

As you can see from the description, such variables do not store values, but only references to memory areas. As an example, if you have a variable for gameobject with a "player" and you assign to it the "enemy" object, then your "player" will be not destroyed, you will just change the reference to another object in this variable. The object pointed to by this reference is a class with a name by type of variable. So you can create a reference variable for components and objects in Unity. The main use of such variables in Unity is access to object/component or to its functions and variables. As example:

Spoiler GameObject:
All objects in the scene are gameobjects. Therefore GameObject as a base class is used quite often. Like most classes, it contains not only different variables, but also functions. Check Unity Documentation for details. GameObject player;
//Search for an object with the Enemy tag and create a variable with a reference to it
GameObject enemy = GameObject.FindWithTag ("Enemy");
Transform:
One of the most commonly used components. Every gameobject in Unity has this component. Responsible for the location and size of the object in the game world. Unity has simplified access to the Transform component through the gameobject.transform command. Check Unity Documentation for details. Transform enemyPosition;
//get X-value from the position
float x = enemyPosition.position.x;
Sprite:
The class representing the 2D image (sprite) as a resource in Unity. If you import a sprite in Unity, a new class containing this sprite with its various settings will be automatically created. You will need this for SpriteRenderer component. See the Unity Documentation for description. Sprite enemyBullet;
SpriteRenderer:
The class responsible for sprites rendering on the screen. The resource for rendering will be taken from Sprite (see above). Like most components, it contains various variables and functions. See Unity Documentation for description. SpriteRenderer sr;
//access to SpriteRenderer and change variable, which controlls flip on Y-axe.
GetComponent < SpriteRenderer > ().flipY = true;
С# scripts and other components:
As I said, your scripts are components in Unity. Therefore, reference variables work in a similar way.
1. Create a variable by type of component (use its name).
2. Link the variable to the component: variable = GetComponent < ComponentName > ();
3. Access on component

As an example, the script from the introduction: Moving moving;
moving = GetComponent < Moving > ();
moving.playerShip.transform.position = new Vector3 (1, 1, 0);
All other components work similarly.

3. Arrays (static and dynamic):

An array is an ordered data structure consisting of elements of the same type. Arrays can be not only one-dimensional, but multi-dimensional. All elements of the array are indexed, for purposeful access to them. A static array has a certain size (the number of elements) that can not be changed after the declaration. The size of the dynamic array can be changed. The indexing of the array begins with 0 (the first element of the array has the index [0]).

Spoiler static arrays:
Since the size of a static array is predetermined, the speed of working with this array is higher. Use static arrays if the size of the array is known in advance and will be constant. //Declaration of a two-dimensional array of type int , consisting of 2 * 5 elements
int [,] numbers = new int [2, 5];
//Declaration of a one-dimensional array of type GameObject , the size of the array is determined through the gameobjects inspector
public GameObject [] enemy;
//Declaration of a one-dimensional array of type string and its initialization
string[] animals = new string[2] {"cat","dog"};
dynamic arrays:
Dynamic arrays use the List class. This class is in the System.Collections.Generic space, so it's better to attach this namespace to the script using using System.Collections.Generic; . Dynamic arrays allow various actions with the size of the array. You can add, insert and delete items. Check MSDN for description. //add namespace to work with the List class
using System.Collections.Generic;
//Declaration of a dynamic array of type string
List <string> cars = new List<string>();
//Adding a new element to the array
cars.Add("VW");
//Inserting a new element into an array as the first element
cars.Insert(0,"Audi");
//deleting the element "VW"
cars.Remove("VW");

4. Access Modifiers:

In C # variables can be at different levels of access.

Spoiler private:
By default (if you did not specify a variable), it gets a private access level. You can also specify this level with keyword private . Access to such variables is possible only within their containing classes. float speed;
private int score;
public:
The access level public gives unlimited access. For example, you can change such variables from other classes. Also, the variable with public access will be visible in the editor, this allows its configuration through the inspector. The components in Unity have a public access level. public float speed;
public GameObject player;
protected:
The access level for the current and inherited classes.

5. Areas of visibility (actions) of variables:

The location of the variable declaration determines its visibility in the containing script.

Spoiler globally in class:
A variable declared in the class, but not included in the function of this class can be used globally by all functions of this class.
locally in the function:
The variable declared in the function can only be used in this function.
locally in a loop:
The visibility of such a variable is even smaller, it is only used locally within the loop. using UnityEngine;
using System.Collections;

public class Moving : MonoBehaviour {

//the variable speed can be used by any function of this class
public int speed;

void RandomFunction () {
//the isMoving variable can only be used within RandomFunction () {...}
bool isMoving = true;
//the variable i can only be used within a loop
for (int i = speed; i < 0; i--) {
speed = i;
}
isMoving = false;
}
}

6: Arithmetic Operators:

Various arithmetic operations are possible with variables containing values. Here I will give only basic examples.

Spoiler Be careful with arithmetic operations with different types of variables. If, for example, writing a fractional result into an integer variable, the fractional part will be lost. float a = 10;
float b = 5;
float c;
//addition: c = 10 + 5
c = a + b;
//subtraction: a = 10 - 2
a = a - 2;
//division: b = 8 / 2
b = a / 2;
//multiplication: с = 10 * 1.5
с = 10 * 1.5;
//assignment: a = 15
a = c;
//Increment: increase of a by one
a++;
//Decrement: decreasing a by one
a--;
//Increment / decrement: can stand before or after the variable, changing the order of calculations

7. Mathematical Functions:

In C #, there is an Mathf structure for various mathematical functions. Check Unity Documentation for description.

Spoiler //The function will return -1, since the check result is negative
float sign = Mathf.Sign (-5);

8. Conditions and Boolean Operators:

For choosing another version of the execution programs have different conditional operators.

Spoiler Logical comparison operators:
The result of the comparison is a binary result, that is false or true. The following comparisons are possible:

== - equally
!= - not equal
> - larger
< - less
>= - more or equal
<= - less or equal

Conditional statements:
Conditional operators allow you to compare and execute a certain part of the code depending on the result. if ... else:
The short form of this conditional statement consists only of the condition and the part of the code to be executed, if the condition is true. if (hp <= 0) {
isDead = true;
canFight = false;
} The complete form consists of the condition that the part of the code is executing if the condition is true and the part of the code executed if the condition is false. if (hp <= 0) {
isDead = true;
canFight = false;
} else {
isDead = false;
canFight = true;
} It is possible to combine different conditions into one design. if (hp <= 0) {
isDead = true;
canFight = false;
} else if (hp == 100) {
isDamaged = false;
} Binary logical operators:
With the help of such operators, you can create more complex conditions.

&& - logical AND . It will be true if both conditions are true. Or it is false if both or one of them is false.
|| - logical OR . It will be true if one of the conditions is true. And it is false if both conditions are false.
if (hp < 0 || hp > 0) {
isZero = false;
} else {
isZero = true;
} switch:
This logical operator is used to process a variety of options when finding the true value. string direction = "left";

//Sought expression
switch (direction) {
//An option, if it is the same, then the following code is executed
case ("up"):
move = Vector2.up;
isMoving = true;
//Interrupts the further execution of the logical operator (if the variant coincides)
break;
//An option, if it is the same, then the following code is executed
case ("down"):
move = Vector2.down;
isMoving = true;
//Interrupts the further execution of the logical operator (if the variant coincides)
break;
//In this example, this part of the code will be executed and the logical operator will be finished
case ("left"):
move = Vector2.left;
isMoving = true;
//Interrupts the further execution of the logical operator (if the variant coincides))
break;
//An option, if it is the same, then the following code is executedд
case ("right"):
move = Vector2.down;
isMoving = true;
//Interrupts the further execution of the logical operator (if the variant coincides)
break;
//If none of the options were true, then the code piece after default is executed,
default:
move = Vector2.zero;
isMoving = false;
//Interrupts the further execution of the logical operator
break;
}

9. Loops:

Loops are used to repeatedly execute certain tasks (code fragments).

Spoiler for:
This loop is executed a certain number of times. //For example, the declaration of an array of 10 int elements
public int[] numbers = new int[10];

//int i = 0; Declaration with the initialization of the loop counter
//i < 10; Check the ability to run the next loop (until the condition is true)
//i++; Changing the loops counter
for (int i = 0; i < 10; i++) {
//The executable part of the code for each new loop
//In this example, filling the array with numbers from 0 to 9
numbers [i] = i;
} Although this is not necessary, I advise you to use integer values in the loop counters to avoid errors from fractional computations.

while:
This loop is executed while the condition is true. //For example, the declaration of an array of 10 int elements
public int[] numbers = new int[10];
//Declaration with the initialization of the variable k, which we will use to check the condition of the loop
int k = 9;

//Check the loop condition, execute a loop if the condition is true
while (k >= 0){
//Executable code fragment in curly brackets
//Filling the array with numbers from 9 to 0 in reverse order
numbers [k] = k; //Decreasing the variable by 1 (to get a false condition)
k--;
} Be careful with the loops so you do not get an "eternal" loop, when the condition is always true and the cycle repeats forever.

do...while:
The difference between this loop and the while loop is that the condition is checked after the code fragment is executed. Therefore, this cycle will always be executed at least once. //Public variable declaration
public string testText;
//Declaration and initialization of an integer variable, for a loop condition
int j = 0;

//Execution of a code fragment of a loop
do {
//Adding a digit converted to a text symbol to a text variable
testText = testText + j.ToString();
//Increased j by a one
j ++;
//Check the condition, repeat the loop if the condition is true
} while (j < 10);
//The result of the loop is the text "0123456789"
foreach:
Loop for working with arrays. Processes elements in turn. //Declaration and initialization of the array
int [] numbers = new int[5] {21,28,13,4,15};
//Array declaration for copying
int [] numbersCopy = new int[5];

//Auxiliary variable for array index
int i = 0;
//Start a loop of an array that has passed through all elements
//The number variable must match the type of array elements
foreach (int number in numbers) {
//Copy the current element to another array
numbersCopy [i] = number;
//Increase the index by 1, to access the next element in the array for the copy
i++;
}
//The result of the cycle is copying elements into a new array
operators break and continue:
These operators help manage the execution of cycles.
break - this operator stops the loop and proceeds to further execution of the program
continue - this operator stops the current execution of the loop and starts a new one
//Auxiliary variable for array index
int i = 0;
//Start a loop of an array that has passed through all elements
//The number variable must match the type of array elements
foreach (int number in numbers) {
//Copy the current element to another array
numbersCopy [i] = number;
//Increase the index by 1, to access the next element in the array for the copy
i++;
//As the variable for the index became 3, we stop execution of the cycle
if (i == 3)
break;
}

10. Functions:

A function is a separate piece of code to perform a specific task. The function can be called many times in those cases when it is necessary to solve this problem. This avoids repetition of the code. Functions can be either made by you individually for the achievement of your goals, or by preparations from Unity for standard solutions. Functions are part of the classes. Functions, like variables, have different levels of access. public functions can be accessed from other classes, access to private functions is possible only within their containing classes. For the functions to work, you may need input data - arguments (functions can also use global variables of their containing classes). After its work, the function can return some result (use Return to return the result). The type of the function must match the type of the result to return. There are also functions that do not return a result, such functions have the type void .

Spoiler Standard functions from Unity:
There are many different functions in Unity. Here I show a small example of them. In the future, the tutorials will come across new features.

Instantiate:
This function puts the clone of the object in the scene. It is usually used for cloning a prefab. //Creates a prefab clone in a scene at a given position (Vector3) with a specified rotation (Quaternion)
Instantiate (prefab, position, rotation); Destroy:
This function deletes the object from the scene. //Removes the game object from the scene after the specified interval (or immediately if the time does not specify)
Destroy (gameobject, time); Functions of classes:
Often, if you use a component (class), it contains various functions for working with it. The list of these functions can be seen in the C # editor after the set of the reference variable (+ dot) pointing to this component. //Modifies the fractional variable in the animator component
GetComponent < Animator > ().SetFloat ("Speed", 0);
User functions:
Of course, you can use your own functions to perform the necessary tasks. //Damage function
public void DoDamage (int damage) {
hp = hp - damage;
if (hp <= 0)
Destroy (gameObject);
}

11. Events:

Events are similar to functions, only their launch is tied to various events. I will give just a few examples.

Spoiler void Awake() {...} //This event is called once when the script is loaded. Typically used to initialize objects.
void Awake() {
//C#
} void Start() {...} //This event is called once after all the void Awake () {...} have been executed. Used to initialize variables.
void Start() {
//C#
} void Update() {...} //This event is called again every new frame. Usually contains the main code for managing the game object.
void Update() {
//C#
} void LateUpdate() {...} //This event is called again every new frame after processing all Update (). Usually used to control the camera to draw an already finished scene.
void LateUpdate() {
//C#
} void FixedUpdate() {...} //This event is called at a fixed interval (default 0.02). Used in physics calculations (physics is not considered in Unity every frame).
void FixedUpdate() {
//C#
} OnTriggerEnter2D() {...}
There are other options for triggering the trigger (Enter, Exit, Stay). //This event is triggered when the collider2D hits the trigger2D. The variable other will contain a reference to the object that was in the trigger.
void OnTriggerEnter2D(Collider2D other) {
//C#
}

Only the basics of C # scripts were shown here. For a more detailed description of the individual parts of C # scripts, see the following tutorials.

Share on Facebook Share on Google+ Share on LinkedIn Share on VK