Let’s look at what you’ve got here. You can ignore the first three lines. They’re just the program setting up things it needs. Then you’ve got this:

public class RoboMover : MonoBehaviour {

This is the start of a class (a blueprint of code) called RoboMover. Don’t worry about the : MonoBehaviour bit right now. Everything between this first { and the last } is inside the RoboMover class.

Then below that, you have two function declarations for functions named Start and Update. A function declaration is where a function gets defined in your code. Right now, the functions are both empty and the only difference between them is their names, so let’s just look at one quickly:

void Update() {

}

A function is a set of instructions for a computer to do something, wrapped up with a label for the task that makes it easy to remember. For example, for a human, “Make me a cup of tea” is a function. We know there are lots of steps to it and, at the end, you have a cup of tea. It would be silly to have to tell someone every step every time you wanted them to make you some tea. The same is true of asking the computer to do something. Much easier to teach it once, in one place, and then get it to do it over and over again just by using the label of the function!

The first word in these function declarations here is void. That shows you that the functions don’t return anything. That means they give nothing back at the end of running. For example, the human function “Make me a cup of tea” returns a cup of tea once all the instructions are done, but “Add milk” doesn’t return anything, it just changes the cup of tea that already exists. So “Add milk” would be a void function!

Next comes the name of the function, that easy label you can use to call the function from elsewhere in your code to use it. Notice the round brackets () beside the name. They’re empty now, but they can be used to pass information into the function. For example: “Make me a cup of tea (two sugars)”.

Finally, you have the curly brackets {}. Everything inside them is the set of instructions the program will follow when the function is called. For “Make me a cup of tea” that would be things like:

• Boil water
• Put water in teapot
• Add teabag
• …and so on

These variables are labels on values, or things. In this case we’ve got:

• moveSpeed — a float (decimal) number, in this case 4.0
• rb — a variable you’ll use to refer to the Rigidbody component (which is MazeRobo itself, remember?)
• tf — a variable you’ll use to refer to the Transform component

The first line of the function creates desiredDirection, which is a set of three coordinates. Two of them are taken from Input, which is the direction the game receives from the player. The last is the depth of the character, which you’re not changing, so it’s set to 0.0.

You then multiply the desiredDirection by moveSpeed, the variable you set earlier that controls the speed at which MazeRobo moves.

Next, you multiply desiredDirection again by Time.deltaTime, which is the amount of time since the last time Update ran. This means the direction changes correctly no matter the type of computer your game runs on.

Finally, you change the position of the Rigidbody rb(that’s MazeRobo) by the amount you’ve calculated and stored in desiredDirection.

What all this adds up to is that, every time the screen is updated, the character moves a tiny bit in the direction the player is sending it with the controls.