Introduction

Game Design

Setting the Scene

Running

using UnityEngine;

public class Runner : MonoBehaviour {

	void Update () {
		transform.Translate(5f * Time.deltaTime, 0f, 0f);
	}
}

Generating a Skyline

using UnityEngine;

public class SkylineManager : MonoBehaviour {

	public Transform prefab;
}

using UnityEngine;

public class SkylineManager : MonoBehaviour {

	public Transform prefab;
	public int numberOfObjects;

	private Vector3 nextPosition;

	void Start () {
		nextPosition = transform.localPosition;
	}
}

using UnityEngine;

public class SkylineManager : MonoBehaviour {

	public Transform prefab;
	public int numberOfObjects;

	private Vector3 nextPosition;

	void Start () {
		nextPosition = transform.localPosition;
		for(int i = 0; i < numberOfObjects; i++){
			Transform o = (Transform)Instantiate(prefab);
			o.localPosition = nextPosition;
			nextPosition.x += o.localScale.x;
		}
	}
}

using UnityEngine;

public class Runner : MonoBehaviour {

	public static float distanceTraveled;

	void Update () {
		transform.Translate(5f * Time.deltaTime, 0f, 0f);
		distanceTraveled = transform.localPosition.x;
	}
}

using UnityEngine;
using System.Collections.Generic;

public class SkylineManager : MonoBehaviour {

	public Transform prefab;
	public int numberOfObjects;
	public float recycleOffset;

	private Vector3 nextPosition;
	private Queue<Transform> objectQueue;

	void Start () {
		objectQueue = new Queue<Transform>(numberOfObjects);
		nextPosition = transform.localPosition;
		for(int i = 0; i < numberOfObjects; i++){
			Transform o = (Transform)Instantiate(prefab);
			o.localPosition = nextPosition;
			nextPosition.x += o.localScale.x;
			objectQueue.Enqueue(o);
		}
	}

	void Update () {
		if(objectQueue.Peek().localPosition.x + recycleOffset < Runner.distanceTraveled){
			Transform o = objectQueue.Dequeue();
			o.localPosition = nextPosition;
			nextPosition.x += o.localScale.x;
			objectQueue.Enqueue(o);
		}
	}
}

using UnityEngine;
using System.Collections.Generic;

public class SkylineManager : MonoBehaviour {

	public Transform prefab;
	public int numberOfObjects;
	public float recycleOffset;

	private Vector3 nextPosition;
	private Queue<Transform> objectQueue;

	void Start () {
		objectQueue = new Queue<Transform>(numberOfObjects);
		for(int i = 0; i < numberOfObjects; i++){
			objectQueue.Enqueue((Transform)Instantiate(prefab));
		}
		nextPosition = transform.localPosition;
		for(int i = 0; i < numberOfObjects; i++){
			Recycle();
		}
	}

	void Update () {
		if(objectQueue.Peek().localPosition.x + recycleOffset < Runner.distanceTraveled){
			Recycle();
		}
	}

	private void Recycle () {
		Transform o = objectQueue.Dequeue();
		o.localPosition = nextPosition;
		nextPosition.x += o.localScale.x;
		objectQueue.Enqueue(o);
	}
}

using UnityEngine;
using System.Collections.Generic;

public class SkylineManager : MonoBehaviour {

	public Transform prefab;
	public int numberOfObjects;
	public float recycleOffset;
	public Vector3 minSize, maxSize;

	private Vector3 nextPosition;
	private Queue<Transform> objectQueue;

	void Start () {
		objectQueue = new Queue<Transform>(numberOfObjects);
		for(int i = 0; i < numberOfObjects; i++){
			objectQueue.Enqueue((Transform)Instantiate(prefab));
		}
		nextPosition = transform.localPosition;
		for(int i = 0; i < numberOfObjects; i++){
			Recycle();
		}
	}

	void Update () {
		if(objectQueue.Peek().localPosition.x + recycleOffset < Runner.distanceTraveled){
			Recycle();
		}
	}

	private void Recycle () {
		Vector3 scale = new Vector3(
			Random.Range(minSize.x, maxSize.x),
			Random.Range(minSize.y, maxSize.y),
			Random.Range(minSize.z, maxSize.z));

		Vector3 position = nextPosition;
		position.x += scale.x * 0.5f;
		position.y += scale.y * 0.5f;

		Transform o = objectQueue.Dequeue();
		o.localScale = scale;
		o.localPosition = position;
		nextPosition.x += scale.x;
		objectQueue.Enqueue(o);
	}
}

Generating Platforms

using UnityEngine;
using System.Collections.Generic;

public class PlatformManager : MonoBehaviour {

	public Transform prefab;
	public int numberOfObjects;
	public float recycleOffset;
	public Vector3 minSize, maxSize, minGap, maxGap;
	public float minY, maxY;

	private Vector3 nextPosition;
	private Queue<Transform> objectQueue;

	void Start () {
		objectQueue = new Queue<Transform>(numberOfObjects);
		for(int i = 0; i < numberOfObjects; i++){
			objectQueue.Enqueue((Transform)Instantiate(prefab));
		}
		nextPosition = transform.localPosition;
		for(int i = 0; i < numberOfObjects; i++){
			Recycle();
		}
	}

	void Update () {
		if(objectQueue.Peek().localPosition.x + recycleOffset < Runner.distanceTraveled){
			Recycle();
		}
	}

	private void Recycle () {
		Vector3 scale = new Vector3(
			Random.Range(minSize.x, maxSize.x),
			Random.Range(minSize.y, maxSize.y),
			Random.Range(minSize.z, maxSize.z));

		Vector3 position = nextPosition;
		position.x += scale.x * 0.5f;
		position.y += scale.y * 0.5f;

		Transform o = objectQueue.Dequeue();
		o.localScale = scale;
		o.localPosition = position;
		objectQueue.Enqueue(o);

		nextPosition += new Vector3(
			Random.Range(minGap.x, maxGap.x) + scale.x,
			Random.Range(minGap.y, maxGap.y),
			Random.Range(minGap.z, maxGap.z));

		if(nextPosition.y < minY){
			nextPosition.y = minY + maxGap.y;
		}
		else if(nextPosition.y > maxY){
			nextPosition.y = maxY - maxGap.y;
		}
	}
}

Jumping and Falling

using UnityEngine;

public class Runner : MonoBehaviour {

	public static float distanceTraveled;

	public float acceleration;

	private bool touchingPlatform;

	void Update () {
		distanceTraveled = transform.localPosition.x;
	}

	void FixedUpdate () {
		if(touchingPlatform){
			rigidbody.AddForce(acceleration, 0f, 0f, ForceMode.Acceleration);
		}
	}

	void OnCollisionEnter () {
		touchingPlatform = true;
	}

	void OnCollisionExit () {
		touchingPlatform = false;
	}
}

using UnityEngine;

public class Runner : MonoBehaviour {

	public static float distanceTraveled;

	public float acceleration;
	public Vector3 jumpVelocity;

	private bool touchingPlatform;

	void Update () {
		if(touchingPlatform && Input.GetButtonDown("Jump")){
			rigidbody.AddForce(jumpVelocity, ForceMode.VelocityChange);
		}
		distanceTraveled = transform.localPosition.x;
	}

	void FixedUpdate () {
		if(touchingPlatform){
			rigidbody.AddForce(acceleration, 0f, 0f, ForceMode.Acceleration);
		}
	}

	void OnCollisionEnter () {
		touchingPlatform = true;
	}

	void OnCollisionExit () {
		touchingPlatform = false;
	}
}

	void Update () {
		if(touchingPlatform && Input.GetButtonDown("Jump")){
			rigidbody.AddForce(jumpVelocity, ForceMode.VelocityChange);
			touchingPlatform = false;
		}
		distanceTraveled = transform.localPosition.x;
	}

Platform Variety

using UnityEngine;
using System.Collections.Generic;

public class PlatformManager : MonoBehaviour {

	public Transform prefab;
	public int numberOfObjects;
	public float recycleOffset;
	public Vector3 minSize, maxSize, minGap, maxGap;
	public float minY, maxY;
	public Material[] materials;
	public PhysicMaterial[] physicMaterials;

	private Vector3 nextPosition;
	private Queue<Transform> objectQueue;

	void Start () {
		objectQueue = new Queue<Transform>(numberOfObjects);
		for(int i = 0; i < numberOfObjects; i++){
			objectQueue.Enqueue((Transform)Instantiate(prefab));
		}
		nextPosition = transform.localPosition;
		for(int i = 0; i < numberOfObjects; i++){
			Recycle();
		}
	}

	void Update () {
		if(objectQueue.Peek().localPosition.x + recycleOffset < Runner.distanceTraveled){
			Recycle();
		}
	}

	private void Recycle () {
		Vector3 scale = new Vector3(
			Random.Range(minSize.x, maxSize.x),
			Random.Range(minSize.y, maxSize.y),
			Random.Range(minSize.z, maxSize.z));

		Vector3 position = nextPosition;
		position.x += scale.x * 0.5f;
		position.y += scale.y * 0.5f;

		Transform o = objectQueue.Dequeue();
		o.localScale = scale;
		o.localPosition = position;
		int materialIndex = Random.Range(0, materials.Length);
		o.renderer.material = materials[materialIndex];
		o.collider.material = physicMaterials[materialIndex];
		objectQueue.Enqueue(o);

		nextPosition += new Vector3(
			Random.Range(minGap.x, maxGap.x) + scale.x,
			Random.Range(minGap.y, maxGap.y),
			Random.Range(minGap.z, maxGap.z));

		if(nextPosition.y < minY){
			nextPosition.y = minY + maxGap.y;
		}
		else if(nextPosition.y > maxY){
			nextPosition.y = maxY - maxGap.y;
		}
	}
}

Game Events

public static class GameEventManager {

	public delegate void GameEvent();
}

public static class GameEventManager {

	public delegate void GameEvent();

	public static event GameEvent GameStart, GameOver;
}

public static class GameEventManager {

	public delegate void GameEvent();

	public static event GameEvent GameStart, GameOver;

	public static void TriggerGameStart(){
		if(GameStart != null){
			GameStart();
		}
	}

	public static void TriggerGameOver(){
		if(GameOver != null){
			GameOver();
		}
	}
}

GUI and Game Start

using UnityEngine;

public class GUIManager : MonoBehaviour {

	public GUIText gameOverText, instructionsText, runnerText;
}

using UnityEngine;

public class GUIManager : MonoBehaviour {

	public GUIText gameOverText, instructionsText, runnerText;

	void Start () {
		gameOverText.enabled = false;
	}

	void Update () {
		if(Input.GetButtonDown("Jump")){
			GameEventManager.TriggerGameStart();
		}
	}
}

using UnityEngine;

public class GUIManager : MonoBehaviour {

	public GUIText gameOverText, instructionsText, runnerText;

	void Start () {
		gameOverText.enabled = false;
	}

	void Update () {
		if(Input.GetButtonDown("Jump")){
			GameEventManager.TriggerGameStart();
		}
	}

	private void GameStart () {
		gameOverText.enabled = false;
		instructionsText.enabled = false;
		runnerText.enabled = false;
		enabled = false;
	}
}

	void Start () {
		GameEventManager.GameStart += GameStart;
		gameOverText.enabled = false;
	}

Game Over

using UnityEngine;

public class GUIManager : MonoBehaviour {

	public GUIText gameOverText, instructionsText, runnerText;

	void Start () {
		GameEventManager.GameStart += GameStart;
		GameEventManager.GameOver += GameOver;
		gameOverText.enabled = false;
	}

	void Update () {
		if(Input.GetButtonDown("Jump")){
			GameEventManager.TriggerGameStart();
		}
	}

	private void GameStart () {
		gameOverText.enabled = false;
		instructionsText.enabled = false;
		runnerText.enabled = false;
		enabled = false;
	}

	private void GameOver () {
		gameOverText.enabled = true;
		instructionsText.enabled = true;
		enabled = true;
	}
}

using UnityEngine;

public class Runner : MonoBehaviour {

	public static float distanceTraveled;

	public float acceleration;
	public Vector3 jumpVelocity;
	public float gameOverY;

	private bool touchingPlatform;

	void Update () {
		if(touchingPlatform && Input.GetButtonDown("Jump")){
			rigidbody.AddForce(jumpVelocity, ForceMode.VelocityChange);
			touchingPlatform = false;
		}
		distanceTraveled = transform.localPosition.x;

		if(transform.localPosition.y < gameOverY){
			GameEventManager.TriggerGameOver();
		}
	}

	void FixedUpdate () {
		if(touchingPlatform){
			rigidbody.AddForce(acceleration, 0f, 0f, ForceMode.Acceleration);
		}
	}

	void OnCollisionEnter () {
		touchingPlatform = true;
	}

	void OnCollisionExit () {
		touchingPlatform = false;
	}
}

Using the Events

using UnityEngine;

public class Runner : MonoBehaviour {

	public static float distanceTraveled;

	public float acceleration;
	public Vector3 jumpVelocity;
	public float gameOverY;

	private bool touchingPlatform;
	private Vector3 startPosition;

	void Start () {
		GameEventManager.GameStart += GameStart;
		startPosition = transform.localPosition;
		gameObject.active = false;
	}

	void Update () { … }

	void FixedUpdate () { … }

	void OnCollisionEnter () { … }

	void OnCollisionExit () { … }

	private void GameStart () {
		distanceTraveled = 0f;
		transform.localPosition = startPosition;
		gameObject.active = true;
	}
}

using UnityEngine;

public class Runner : MonoBehaviour {

	public static float distanceTraveled;

	public float acceleration;
	public Vector3 jumpVelocity;
	public float gameOverY;

	private bool touchingPlatform;
	private Vector3 startPosition;

	void Start () {
		GameEventManager.GameStart += GameStart;
		GameEventManager.GameOver += GameOver;
		startPosition = transform.localPosition;
		gameObject.active = false;
	}

	void Update () { … }

	void FixedUpdate () { … }

	void OnCollisionEnter () { … }

	void OnCollisionExit () { … }

	private void GameStart () {
		distanceTraveled = 0f;
		transform.localPosition = startPosition;
		rigidbody.isKinematic = false;
		gameObject.active = true;
		enabled = true;
	}

	private void GameOver () {
		rigidbody.isKinematic = true;
		enabled = false;
	}
}

using UnityEngine;
using System.Collections.Generic;

public class PlatformManager : MonoBehaviour {

	public Transform prefab;
	public int numberOfObjects;
	public float recycleOffset;
	public Vector3 minSize, maxSize, minGap, maxGap;
	public float minY, maxY;
	public Material[] materials;
	public PhysicMaterial[] physicMaterials;

	private Vector3 nextPosition;
	private Queue<Transform> objectQueue;

	void Start () {
		GameEventManager.GameStart += GameStart;
		GameEventManager.GameOver += GameOver;
		objectQueue = new Queue<Transform>(numberOfObjects);
		for(int i = 0; i < numberOfObjects; i++){
			objectQueue.Enqueue((Transform)Instantiate
			                    (prefab, new Vector3(0f, 0f, -100f), Quaternion.identity));
		}
		enabled = false;
	}

	void Update () { … }

	private void Recycle () { … }

	private void GameStart () {
		nextPosition = transform.localPosition;
		for(int i = 0; i < numberOfObjects; i++){
			Recycle();
		}
		enabled = true;
	}

	private void GameOver () {
		enabled = false;
	}
}

using UnityEngine;
using System.Collections.Generic;

public class SkylineManager : MonoBehaviour {

	public Transform prefab;
	public int numberOfObjects;
	public float recycleOffset;
	public Vector3 minSize, maxSize;

	private Vector3 nextPosition;
	private Queue<Transform> objectQueue;

	void Start () {
		GameEventManager.GameStart += GameStart;
		GameEventManager.GameOver += GameOver;
		objectQueue = new Queue<Transform>(numberOfObjects);
		for(int i = 0; i < numberOfObjects; i++){
			objectQueue.Enqueue((Transform)Instantiate
			                    (prefab, new Vector3(0f, 0f, -100f), Quaternion.identity));
		}
		enabled = false;
	}

	void Update () { … }

	private void Recycle () { … }

	private void GameStart () {
		nextPosition = transform.localPosition;
		for(int i = 0; i < numberOfObjects; i++){
			Recycle();
		}
		enabled = true;
	}

	private void GameOver () {
		enabled = false;
	}
}

Power-Up

using UnityEngine;

public class Booster : MonoBehaviour {

	public Vector3 offset, rotationVelocity;
	public float recycleOffset, spawnChance;
}

using UnityEngine;

public class Booster : MonoBehaviour {

	public Vector3 offset, rotationVelocity;
	public float recycleOffset, spawnChance;

	public void SpawnIfAvailable(Vector3 position){
	}
}

using UnityEngine;
using System.Collections.Generic;

public class PlatformManager : MonoBehaviour {

	public Transform prefab;
	public int numberOfObjects;
	public float recycleOffset;
	public Vector3 minSize, maxSize, minGap, maxGap;
	public float minY, maxY;
	public Material[] materials;
	public PhysicMaterial[] physicMaterials;
	public Booster booster;

	private Vector3 nextPosition;
	private Queue<Transform> objectQueue;

	void Start () { … }

	void Update () { … }

	private void Recycle () {
		Vector3 scale = new Vector3(
			Random.Range(minSize.x, maxSize.x),
			Random.Range(minSize.y, maxSize.y),
			Random.Range(minSize.z, maxSize.z));

		Vector3 position = nextPosition;
		position.x += scale.x * 0.5f;
		position.y += scale.y * 0.5f;
		booster.SpawnIfAvailable(position);

		Transform o = objectQueue.Dequeue();
		o.localScale = scale;
		o.localPosition = position;
		int materialIndex = Random.Range(0, materials.Length);
		o.renderer.material = materials[materialIndex];
		o.collider.material = physicMaterials[materialIndex];
		objectQueue.Enqueue(o);

		nextPosition += new Vector3(
			Random.Range(minGap.x, maxGap.x) + scale.x,
			Random.Range(minGap.y, maxGap.y),
			Random.Range(minGap.z, maxGap.z));

		if(nextPosition.y < minY){
			nextPosition.y = minY + maxGap.y;
		}
		else if(nextPosition.y > maxY){
			nextPosition.y = maxY - maxGap.y;
		}
	}

	private void GameStart () { … }

	private void GameOver () { … }
}

using UnityEngine;

public class Booster : MonoBehaviour {

	public Vector3 offset, rotationVelocity;
	public float recycleOffset, spawnChance;

	void Start () {
		GameEventManager.GameOver += GameOver;
		gameObject.active = false;
	}

	public void SpawnIfAvailable (Vector3 position) {
		if(gameObject.active || spawnChance <= Random.Range(0f, 100f)) {
			return;
		}
		transform.localPosition = position + offset;
		gameObject.active = true;
	}

	private void GameOver () {
		gameObject.active = false;
	}
}

using UnityEngine;

public class Booster : MonoBehaviour {

	public Vector3 offset, rotationVelocity;
	public float recycleOffset, spawnChance;

	void Start () { … }

	void Update () {
		if(transform.localPosition.x + recycleOffset < Runner.distanceTraveled){
			gameObject.active = false;
			return;
		}
		transform.Rotate(rotationVelocity * Time.deltaTime);
	}

	public void SpawnIfAvailable (Vector3 position) { … }

	private void GameOver () { … }
}

using UnityEngine;

public class Booster : MonoBehaviour {

	public Vector3 offset, rotationVelocity;
	public float recycleOffset, spawnChance;

	void Start () { … }

	void Update () { … }

	void OnTriggerEnter () {
		Runner.AddBoost();
		gameObject.active = false;
	}

	public void SpawnIfAvailable (Vector3 position) { … }

	private void GameOver () { … }
}

using UnityEngine;

public class Runner : MonoBehaviour {

	public static float distanceTraveled;

	public float acceleration;
	public Vector3 jumpVelocity;
	public float gameOverY;

	private bool touchingPlatform;
	private Vector3 startPosition;

	private static int boosts;

	void Start () { … }

	void Update () { … }

	void FixedUpdate () { … }

	void OnCollisionEnter () { … }

	void OnCollisionExit () { … }

	private void GameStart () {
		boosts = 0;
		distanceTraveled = 0f;
		transform.localPosition = startPosition;
		rigidbody.isKinematic = false;
		gameObject.active = true;
		enabled = true;
	}

	private void GameOver () { … }

	public static void AddBoost(){
		boosts += 1;
	}
}

using UnityEngine;

public class Runner : MonoBehaviour {

	public static float distanceTraveled;

	public float acceleration;
	public Vector3 boostVelocity, jumpVelocity;
	public float gameOverY;

	private bool touchingPlatform;
	private Vector3 startPosition;

	private static int boosts;

	void Start () { … }

	void Update () {
		if(Input.GetButtonDown("Jump")){
			if(touchingPlatform){
				rigidbody.AddForce(jumpVelocity, ForceMode.VelocityChange);
				touchingPlatform = false;
			}
			else if(boosts > 0){
				rigidbody.AddForce(boostVelocity, ForceMode.VelocityChange);
				boosts -= 1;
			}
		}
		distanceTraveled = transform.localPosition.x;

		if(transform.localPosition.y < gameOverY){
			GameEventManager.TriggerGameOver();
		}
	}

	void FixedUpdate () { … }

	void OnCollisionEnter () { … }

	void OnCollisionExit () { … }

	private void GameStart () { … }

	private void GameOver () { … }

	public static void AddBoost(){ … }
}

Informative GUI

using UnityEngine;

public class GUIManager : MonoBehaviour {

	public GUIText boostsText, distanceText, gameOverText, instructionsText, runnerText;

	void Start () { … }

	void Update () { … }

	private void GameStart () { … }

	private void GameOver () { … }
}

using UnityEngine;

public class GUIManager : MonoBehaviour {

	public GUIText boostsText, distanceText, gameOverText, instructionsText, runnerText;

	private static GUIManager instance;

	void Start () {
		instance = this;
		GameEventManager.GameStart += GameStart;
		GameEventManager.GameOver += GameOver;
		gameOverText.enabled = false;
	}

	void Update () { … }

	private void GameStart () {
		gameOverText.enabled = false;
		instructionsText.enabled = false;
		runnerText.enabled = false;
		enabled = false;
	}

	private void GameOver () { … }

	public static void SetBoosts(int boosts){
		instance.boostsText.text = boosts.ToString();
	}

	public static void SetDistance(float distance){
		instance.distanceText.text = distance.ToString("f0");
	}
}

using UnityEngine;

public class Runner : MonoBehaviour {

	public static float distanceTraveled;

	public float acceleration;
	public Vector3 boostVelocity, jumpVelocity;
	public float gameOverY;

	private bool touchingPlatform;
	private Vector3 startPosition;

	private static int boosts;

	void Start () { … }

	void Update () {
		if(Input.GetButtonDown("Jump")){
			if(touchingPlatform){
				rigidbody.AddForce(jumpVelocity, ForceMode.VelocityChange);
				touchingPlatform = false;
			}
			else if(boosts > 0){
				rigidbody.AddForce(boostVelocity, ForceMode.VelocityChange);
				boosts -= 1;
				GUIManager.SetBoosts(boosts);
			}
		}
		distanceTraveled = transform.localPosition.x;
		GUIManager.SetDistance(distanceTraveled);

		if(transform.localPosition.y < gameOverY){
			GameEventManager.TriggerGameOver();
		}
	}

	void FixedUpdate () { … }

	void OnCollisionEnter () { … }

	void OnCollisionExit () { … }

	private void GameStart () {
		boosts = 0;
		GUIManager.SetBoosts(boosts);
		distanceTraveled = 0f;
		GUIManager.SetDistance(distanceTraveled);
		transform.localPosition = startPosition;
		rigidbody.isKinematic = false;
		gameObject.active = true;
		enabled = true;
	}

	private void GameOver () { … }

	public static void AddBoost(){
		boosts += 1;
		GUIManager.SetBoosts(boosts);
	}
}

Particle Effects

using UnityEngine;

public class ParticleEmitterManager : MonoBehaviour {

	public ParticleEmitter[] emitters;

	void Start () {
		GameEventManager.GameStart += GameStart;
		GameEventManager.GameOver += GameOver;
		GameOver();
	}

	private void GameStart () {
		for(int i = 0; i < emitters.Length; i++){
			emitters[i].ClearParticles();
			emitters[i].emit = true;
		}
	}

	private void GameOver () {
		for(int i = 0; i < emitters.Length; i++){
			emitters[i].emit = false;
		}
	}
}

Downloads

runner.zip

The finished project.

Questions & Answers

What's a collider?

A collider is a physics concept used by Unity's physics engine. They can function as either obstacles, causing collisions, or detectors, triggering events.

Why remove the colliders?

Because the cubes will be used for the noninteractive background only, nothing will ever collide with then. There's no point in the physics engine keeping track of their colliders, so we simply remove them.

What's a material?

Materials are used to define the visual properties of objects. They can range from very simple, like a constant color, to very complex.

Materials consist of a shader and whatever data the shader needs. Shaders are basically scripts that tell the graphics card how an object's polygons should be drawn.

The standard diffuse shader uses a single color and optionally a texture, along with the light sources in the scene, to determine the appearance of polygons.

What about the fourth color component?

Although colors have four components, I'm mentioning only three. The fourth component is the alpha value, which represents the opacity of the color. I assume this value is 255 by default, though it doesn't really matter as we won't create any materials that take alpha into account.

What does it mean to be a child?

Beyond the obvious effect on the object hierarcy, being a child means that you are subject to the Transform component of your parent. Your own transformation is relative to your parent's. When it moves, so do you. When it rotates, you orbit around its pivot. When it scales, both your size and your relative position scale as well.

From a low-level graphics point of view, the hierarchy corresponds to how the transformation matrix stack is created. The parent's matrix is pushed first, then the child's matrix.

What's a prefab?

A prefab is a Unity object – or hierarchy of objects – that doesn't exist in the scene and hasn't been activated. You use it as a template, creating clones of it and adding those to the scene.

What does Instantiate do?

The Object class, which every MonoBehaviour inherits from, contains the static Instantiate method. This method creates a clone of whatever Object instance you pass to it. Optionally, you can supply a new position and rotation for the clone, otherwise it keeps the values of the original.

Note that Instantiate returns an Object reference. If you want to do something with the new clone, you have to cast it to the correct type.

Typically, this method is used with prefabs, but you can also clone objects that already exist in the scene.

What does += do?

The code x += y; adds x and y together and assigns the result back to x. You can consider it a short alternative for the code x = x + y;

There are other operators that behave in a similar fashion, like -=, *=, and /=.

Why is distanceTraveled static?

Because static variables exist independent of object instances, we can access it everywhere via Runner.distanceTraveled. If it were nonstatic, we first need to get a reference to our runner instance before we could get to distanceTraveled.

Of course, we could just add a Runner variable to SkylineManager and assign Runner to it. However, this approach gets unwieldy when we'll need the value in multiple scripts later.

What's a Queue?

The System.Collections.Generic namespace contains the Queue class, which can be used to represent a first in, first out queue. By constantly moving the first entry in the queue to the end of it, we effectively get a rotating ring.

Queue is a generic class that can deal with any one type of content. In this case, we use Queue<Transform> to declare a queue of Transform references.

You can add to the end of the queue by using the Enqueue method. Taking out the first item is done with the Dequeue method. Additionaly, you can get to the first item without removing it via the Peek method.

What does Random.Range do?

Random is a utility class that contains some stuff to create random values. Its Range method can be used to generate a random value within some range.

There are two versions of the Range method. You can call it with two floats, in which case it returns a float between the minimum and maximum value, both inclusive.

Alternatively, you can call Range with two integers, in which case it returns an integer between the minimum, inclusive, and maximum, exclusive. A typical use for this version is selecting an index at random, like someArray[Random.Range(0, someArray.Length)].

What's a rigidbody?

A rigidbody is a physics concept, literally a rigid body that doesn't deform. Unity's physics engine will simulate real-world physics behavior for all objects with RigidBody components, causing them to fall, move, and collide with other stuff.

It is also possible to have soft bodies, which do deform, like cloth.

What's a physic material?

Physic materials are like regular materials, except they deal with collision instead of visual properties. When objects collide, what happens depends on whether they're made of stone, wood, ice, rubber, or some other substance. You use physic materials to simulate this behavior by configuring friction and bounciness.

When is FixedUpdate called?

The physics engine works by dividing time into little discrete steps – by default 0.02 seconds – during which it moves objects and then checks for collisions and triggers. It keeps doing that in a loop until it has caught up with real time.

The FixedUpdate method works like Update, except that it's called once per physics step instead of once per frame. In other words, FixedUpdate is independent of the frame rate. So if you want your code to be independent of the frame rate, put it in this method.

What does AddForce do?

The AddForce method applies a force to a rigidbody, which might result in an acceleration, which builds up velocity, which results in movement.

There are actually various ways to use this method, which you control with the second parameter. For example, if you want to apply a specific acceleration, regardless of an object's mass, you can use the ForceMode.Acceleration option. If you want to directly adjust the velocity, you can use ForceMode.VelocityChange.

What does && do?

The && operator is used for boolean logic and stands for 'and also'. In other words, x && y is only true if both x and y are true.

Note that if x is found to be false, there's no point in checking y anymore. If y were a method call, it won't be invoked. Because of this, when Runner isn't touching the platform, the input won't be checked at all.

The companion of && is the || operator, which stands for 'or else'. So x || y is true if at least one of them is. Also, if x is found to be true, then y will not be considered.

What does Input.GetButtonDown do?

Input is a utility class that contains stuff to detect the player's input. This can be anything from button presses to mouse movement to joystick motion.

The GetButtonDown method can be used to check whether the user just pressed down a key associated with some button or action. Correspondingly, the GetButtonUp method can be used the check whether the user just released it. Also, the GetButton method tells you whether the button is current held down.

Shouldn't the jump be in FixedUpdate?

When the player presses a jump button, we want the velocity change to happed exactly once. For single instantaneous events, putting the code in Update is equivalent to writing code that would activate once in the next FixedUpdate.

Why is the class static?

By marking a class as static you require that its contents are static as well. There can't be any nonstatic variables or methods and it cannot be used to create object instances. In other words, a static class is not a blueprint for objects.

What's a delegate?

Besides simple values and object references, you also store method references in a variable. Such a variable is known as a delegate.

You define a delegate type as if you're creating a method, except there's no code body. After that, you can use this type to create a delegate variable, to which you can assign any method that matches the type. You can then treat this variable like a method. In fact, you can treat a delegate like a list and add multiple methods to it. All of them will be called when you invoke the variable.

The Graphs tutorial uses delegates to dynamically select what kind of graph to generate.

What's an event?

For our purposes, an event is a restricted form of a delegate, forced to behalve like a list. We could use a regular delegate variable instead and it would work just fine.

Both events and delegates allow methods to be added and removed from them, via myEvent += myMethod and myEvent -= myMethod. A delegate also allows a direct assignment, via myDelegate = myMethod. Doing so replaces whatever other methods had been added to it before. We only want the former functionality and not the latter. By disallowing it altogether, we protect ourselves from a potentially hard to find bug caused by forgetting to write a single + somewhere.

What's null?

The default value of a variable that's not a simple value is null. This means that the variable doesn't reference anything yet. Trying to invoke or access anything from a variable that's null results in an error. You can test for this value to make sure that doesn't happen. You can also set such a variable to null yourself, in case you no longer need whatever it was referencing.

What does != do?

The != operator checks whether two things are different. For example, 1 != 2 is true, while 2 != 2 is false. In our case, we're checking whether our event isn't null, which it would be if no methods had been added to it.

In contrast, the == operator checks whether two things are equal.

Note that for object references, equality is usually a matter identity. Two different objects with the exact same contents are not considered equal.

What's with the text positions?

The GUI text is not drawn in 3D but in 2D, relative to the screen. A position of (0, 0) corresponds to the lower left corner, while (1, 1) corresponds to the top right corner.

Why trigger and handle the same event?

If we trigger the game start event, why not simply put the disabling code right after the call to TriggerGameStart?

Any code that deals with the game start has nothing to do with the Update method. Regardless how a game start is triggered, it should simply work. That's why we put the code in the appropriate event handler method. If we ever add another way to start a new game, GUIManager will respond to the event just fine.

Why immediately reset the distance?

Leaving it to the Update method to override distanceTraveled could lead to bugs. For example, if Platform Manager happens to be updated before Runner, it would recycle based on the old distance. If this distance is far ahead, the first platform will be recycled immediately, causing Runner to plummet to its doom.

There are ways to enforce the order in which components are updated, but it is better to guarantee correct results regardless of update order. If you provide public data, make sure it's always up to date.

What does it mean to be kinematic?

A kinematic rigidbody will not be moved by the physics engine. However, other things will still react to it appropriately. In a way, it's a physics object that defies the laws of physics.

What's Quaternion.identity?

Quaternion.identity is a static property that corresponds to the identity quaternion, which results in no rotation.

Why a specular shader?

The default specular shader works like the diffuse shader, except that it also has a specular color and a shininess value. The shader uses these to add a highlight to the visuals.

We use this shader for Booster because it results in more vivid color changes while it rotates.

What does it mean to be a trigger?

By default, a collider acts like a solid object. You can use the OnCollisionEnter method to detect when something hits it.

If a collider is a trigger, it's like a ghost and does not influence the movement of other physics object. Instead, it acts like a radar or alarm. You can use the OnTriggerEnter method to detect when something enters the collider's volume.

What does return do?

You use the return keyword to incidate that a method is finished. Implicitly, it's at the end of every method. You can use it to add multiple exit paths to a method.

In our case, we check whether Booster shouldn't be spawned, either because it's already active or because of the spawn chance. If we shouldn't spawn, we simply return back to where the method was called.

In case a method produces some result – like a number, shown in the Graphs tutorial – you need to explicitly declare what result it returns.

What's Time.deltaTime?

Time is a utility class for time-related stuff. Its deltaTime property contains the amount of seconds passed since the last frame, or since the last fixed time step is called inside FixedUpdate.

What's this?

The this keyword is a reference to an object itself. As a consequence, it can only be used inside nonstatic methods.

Whenever you're accessing a variable of an object inside one of its methods, you're implicitly using this to access it. For example, inside the Update method, transform is the same as this.transform.

Why not set the labels from Runner?

By putting a manager in between Runner and the GUI, we make both independent of each other. The Runner class doesn't deal with GUI details, only with runner details.

If we were to change the GUI – like using icons to display boosts instead of a label – we only need to modify GUIManager, the rest of the game doesn't care about the change.

We could go one step further and not make Runner call the GUI manager at all. Then it would be up to GUIManager to get the boost count from Runner instead. However, then the manager must know details about the runner, which it really shouldn't. Complete decoupling might be achieved by using an event for this, but that's a rather heavy-handed approach for a straightforward case like this. A simple call to a manager is fine.

Why call GameOver in Start?

Initially, we want our particle systems to not emit, until the first game-start event is triggered. So we need to loop over all emitters and shut them off. Because that's the exact same thing that our GameOver method does, we call it instead of writing the code thing twice.