Scripts as Behaviour Components

Variables and Functions

Conventions and Syntax

IF Statements

Loops

Scope and Access Modifiers

Awake and Start

Update and FixedUpdate

Vector Maths

Enabling and Disabling Components

Activating GameObjects

Translate and Rotate

Look At

Linear Interpolation

Destroy

GetButton and GetKey

GetAxis

OnMouseDown

GetComponent

DeltaTime

DataTypes

Classes

Instantiate

Arrays

Invoke

Enumerations

Switch Statements

Start MonoBehaviour Methods

Detecting Mouse Clicks

Time

Learn about programming for game development, from the very beginning with these easy to follow video tutorials.

Beginner Scripting

Setting up the Game

Moving the Player

Moving the Camera

Setting up the Play Area

Creating Collectibles

Detecting Collisions with Collectibles

Displaying Score and Text

Building the Game

Adding AI Navigation

Welcome to 3D Beginner: Roll-a-Ball Game! In this learning project, you’ll:  

Use Unity Editor and its built-in capabilities to set up a simple game environment

Write your own custom scripts to create the game functionality

Create a basic user interface to improve the game experience

Build your game, so other people can play it!

3D Beginner: Roll-a-Ball Game

Recorded Video Session: Text Adventure Game Part 1

Recorded Video Session: Text Adventure Game Part 2

Dive into scripting, in this course we will cover the fundamentals of C#. 

fa671f78-02ca-52da-8151-6d5b2377c1b6:IJ50VM7ryBj2kIwUvpBNXY

When making games it can sometimes be useful to linearly interpolate between two values. This is done with a function called Lerp. 

This tutorial is included in the Beginner Scripting project.

Games

AI, ML Curricular Framework Resources 

Beginner Scripting (Acc-Sol)

When making games it can sometimes be useful to linearly interpolate between two values. This is done with a function called Lerp. Linearly interpolating is finding a value that is some percentage between two given values. For example, we could linearly interpolate between the numbers 3 and 5 by 50% to get the number 4. This is because 4 is 50% of the way between 3 and 5.

In Unity there are several Lerp functions that can be used for different types. For the example we have just used, the equivalent would be the Mathf.Lerp function and would look like this:

// In this case, result = 4
float result = Mathf.Lerp (3f, 5f, 0.5f);

The Mathf.Lerp function takes 3 float parameters: one representing the value to interpolate from; another representing the value to interpolate to and a final float representing how far to interpolate. In this case, the interpolation value is 0.5 which means 50%. If it was 0, the function would return the ‘from’ value and if it was 1 the function would return the ‘to’ value.

Other examples of Lerp functions include Color.Lerp and Vector3.Lerp. These work in exactly the same way as Mathf.Lerp but the ‘from’ and ‘to’ values are of type Color and Vector3 respectively. The third parameter in each case is still a float representing how much to interpolate. The result of these functions is finding a colour that is some blend of two given colours and a vector that is some percentage of the way between the two given vectors.

Vector3 from = new Vector3 (1f, 2f, 3f);
Vector3 to = new Vector3 (5f, 6f, 7f);

// Here result = (4, 5, 6)
Vector3 result = Vector3.Lerp (from, to, 0.75f);

In this case the result is (4, 5, 6) because 4 is 75% of the way between 1 and 5; 5 is 75% of the way between 2 and 6 and 6 is 75% of the way between 3 and 7.

The same principle is applied when using Color.Lerp. In the Color struct, colours are represented by 4 floats representing red, blue, green and alpha. When using Lerp, these floats are interpolated just as with Mathf.Lerp and Vector3.Lerp.

Under some circumstances Lerp functions can be used to smooth a value over time. Consider the following piece of code:

void Update ()
{
    light.intensity = Mathf.Lerp(light.intensity, 8f, 0.5f);
}

If the intensity of the light starts off at 0 then after the first update it will be set to 4. The next frame it will be set to 6, then to 7, then to 7.5 and so on. Thus over several frames, the lights intensity will tend towards 8 but the rate of its change will slow as it approaches its target. Note that this happens over the course of several frames. If we wanted this to not be frame rate dependent then we could use the following code:

void Update () {     light.intensity = Mathf.Lerp(light.intensity, 8f, 0.5f * Time.deltaTime); }

void Update ()
{
    light.intensity = Mathf.Lerp(light.intensity, 8f, 0.5f * Time.deltaTime);
}

This would mean the change to intensity would happen per second instead of per frame.

Please note that when smoothing a value it is often best to use the SmoothDamp function. Only use Lerp for smoothing if you are sure of the effect you want.

Linear Interpolation

1. Linear Interpolation

Complete this tutorial