# Creators – Week 3

This week we continued our project from last week, looked at three main topics:

1. Frame rate independence
2. Creating our own properties on our components
3. The Input Manager and getting and using user input

## Frame Rate Independence

We covered how to make our actions independent of frame-rate. The code:

```transform.Translate(Vector3.forward, 20.0f);
```

moves the object 20m in every frame. As we know, frame-rate isn’t generally consistent between machines. On my powerful laptop, I was getting up to 1400 frames per second at fastest. Most ninjas were getting a few hundred frames per second on theirs.

On the other hand, the code here:

```transform.Translate(Vector3.forward, Time.deltaTime * 20.0f);
```

moves the object at a consistent 20m per second on everyone’s machine. The magic is that Time.deltaTime variable. It is the time, in seconds, since the last frame was drawn. The faster the frame-rate, the smaller this number gets and the result is a consistent 20m per second movement.

## Creating Properties on our Components

We can add properties, variables where we can hold and values that we can then use, to our classes by typing a single line into our class definition:

```class MyBehaviour : MonoBehaviour
{
// The new property
public float myProperty = 1.0f;

void Start()
{
}
void Update()
{
}
}
```

Looking at the bits of the line in turn:

• public – The access modifier. Can be private, internal (which we won’t use) or public. If it’s public we can see it in the inspector, and from other classes. If private we can only see and use it within the class itself.
• float – The type of value we are storing. A float is a number with a decimal point. An int (short for integer) is a number without one. We might use an int for counting things, but we use floats for real world measures like speeds and positions, etc.
• myProperty – the name of the variable
• = 1.0f – Assigning a default value to this property. This portion is optional. the ‘f’ after the number is just a hint to the computer that this is a float value.
• ; – The standard semicolon to end the line of code.

## The Input Manager and Using User Input

Unity’s Input Manager contains the definition of input “Axes”. These can contain many ways of doing the same thing.

The default definition of the “Horizontal” axis means it can be triggered by the keys A and D, or the Left and Right arrow keys or by the joysticks or d-pad on a game controller.

This means input is “abstracted”; we can write our script to respond to input, without worrying how that input is generated.

To get the value of input on an access we need to use code like this:

```forwardInput = Input.GetAxis("Vertical");
```

Here we’re getting the value of the axis called “Vertical” and storing it in a variables called forwardInput.

The value of the vertical axis goes between -1 and 1. Minus one means fully down, zero means no input and one means fully up. Because of this range, we can use this value like a switch, multiply it with other numbers. When there’s no input, it’s zero which will zero out the expression it’s part of.

Here’s the fully updated code for our PlayerController.cs:

```using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerController : MonoBehaviour
{
public float speed = 20.0f;
public float turnSpeed = 50.0f;
private float horizontalInput;
private float forwardInput;

// Start is called before the first frame update
void Start()
{

}

// Update is called once per frame
void Update()
{
// Get the player input
horizontalInput = Input.GetAxis("Horizontal");
forwardInput = Input.GetAxis("Vertical");

//  Move our vehicle forward
transform.Translate(Vector3.forward * Time.deltaTime *
speed * forwardInput);

// Rotate our vehicle
transform.Rotate(Vector3.up, turnSpeed * Time.deltaTime *
horizontalInput);
}
}

```

## Code for this Week

Updated code is on our GitHub repo: https://github.com/coderdojoathenry/Creators-2022