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

Adding AI Navigation

Building the Game

Welcome to Roll-a-ball! 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!

Create_a_new_Scene-Transcript.txt

Create_a_primitive_plane-Transcript.txt

Scale_the_Ground_Plane-Transcript.txt

Create_a_Player_GameObject-Transcript.txt

Adjust_the_default_lighting-Transcript.txt

Add_colors_with_Materials-Transcript.txt

Create-a-new-Unity-Project-Transcript.txt

Overview

Before you begin

Create a new Unity project

Create a new Scene

Create a primitive plane

Scale the Ground Plane

Create a Player GameObject

Adjust the default lighting

Add colors with Materials

Create_a_new_Unity_project-Transcript.txt

 In the second Roll-a-ball tutorial, you’ll:

Add a Rigidbody to the Player sphere, so you can use the Unity physics engine

Write your own PlayerController script in C#, to make the sphere respond to player input

Add_a_Rigidbody_to_the_Player-Transcript.txt

Install_the_Input_System_package-Transcript.txt

Add_a_Player_Input_component-Transcript.txt

Create_a_new_script-Transcript.txt

Write_the_OnMove_function_Declaration-Transcript.txt

Add_input_data_to_the_Player-Transcript.txt

Apply_force_to_the_Player-Transcript.txt

Fix_the_Player_movement_speed-Transcript.txt

Add a Rigidbody to the Player 

Install the Input System package

Add a Player Input component

Create a new script

Write the OnMove function declaration

Apply input data to the Player

Apply force to the Player

Fix the Player movement speed

Final script sample

Add-a-Player-Input-Component-Transcript.txt

In this third Roll-a-ball tutorial, you’ll:

Write a script to make the Camera follow the Player sphere with a fixed offset

Set_the_Camera_position-Transcript.txt

Write_a_CameraController_script-Transcript.txt

Reference_the_Player_GameObject-Transcript.txt

Set the Camera position

Write a CameraController script

Reference the Player GameObject

Implement a NavMesh for AI-based enemy navigation.

Add static and dynamic obstacles to challenge the player.

Code win and lose conditions using Unity scripting.

8.1 - Install the AI Navigation package - Transcript.txt

8.2 - Create an enemy - Transcript.txt

8.3 - Bake a NavMesh - Transcript.txt

8.4 - Make the enemy chase the player - Transcript.txt

8.5 - Create static obstacles - Transcript.txt

8.6 - Create dynamic obstacles - Transcript.txt

8.7 - Set the win and lose conditions - Transcript.txt

Install the AI Navigation package

Create an enemy

Bake a NavMesh

Make the enemy chase the player

Create static obstacles

Create dynamic obstacles

Set the win and lose conditions

Final script samples

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

2022.3

3D Beginner Game: Roll-a-Ball

2bfd8cfb-cf55-5d99-ad35-68ccfb47f783:EJWbNZ6QA41b2p9CvaTfi6

Unity_RollABall_2-1.mp4

Unity_RollABall_2-8.mp4

Unity_RollABall_2-6.mp4

Unity_RollABall_2-4.mp4

Unity_RollABall_2-5.mp4

Unity_RollABall_2-7.mp4

Unity_RollABall_2.3_2022_LTS_Update.mp4

Unity_RollABall_2.2_2022_LTS_Update.mp4

2.8.4-tutorial-final-ball-moving.mp4

2.7.5-test-movement-slow.mp4

Unit 2 - Program a basic game

By the end of this tutorial, your game will look something like this: 

To use this tutorial, you will need a Unity project with a Scene containing the ball and the surface it rolls on. If you haven’t already created these, start with the tutorial Setting up the Game.

Follow the video or text instructions below to add a Rigidbody component to the Player GameObject:

Select the Player GameObject in the Hierarchy window.

In the Inspector Window, select Add Component, then search for "Rigidbody" and add the Rigidbody component to the Player GameObject.

Note: Make sure to select Rigidbody and not Rigidbody 2D.

In the Add Component search window, the Rigidbody component is selected.


Follow the video or text instructions below to browse packages in the Unity Registry, install the Input System package in your project, and adjust the build settings:

1.  Browse packages in the Unity registry.

In the main menu, select Window > Package Manager to access the Package Manager window.

From the Packages dropdown, select Unity Registry to see the list of available Unity Packages.


Locate the Input System package and select Install to add the package to the project.

If prompted, select Yes to enable the new system and restart the Unity Editor. 

The Unity Editor should restart with the new package configured.


3.  Adjust the build settings (Windows only)

This step is only necessary for Windows users. If you are using macOS, you do not need to do this.

In the main menu, select File > Build Settings to access the Build Settings window.

In the Build Settings window, under Windows, Mac, Linux settings, change the Architecture to x86_64.

Close the Build Settings window after making this change.

In the Package Manager, the Input System package is selected and the Install button is highlighted.

Follow the video or text instructions below to add the Player Input component and create a new Input Action Asset:

In the Inspector window, add the Player Input component.


In the Player Input component, select Create Actions.

Create a new folder called "Input" to stay organized.

Name the asset “InputActions” and save the Input Action asset within the newly created folder.

If the Input Actions window appears, you can close this window now.

The Create Actions button is highlighted in the Inspector window. In the file explorer window, the file is being saved as InputActions in a folder named Input.


Follow the video or text instructions below to create a new PlayerController script and open it in a script editor:

1.  Create a new PlayerController script.

In the Project window, create a new folder named "Scripts".

With the Player GameObject selected, select Add Component > New Script, then name the new script "PlayerController".

The created script asset will be at the root level of the Assets folder by default. Move the new PlayerController script asset into the Scripts folder.


Double-click the script asset in the Project window to open it in your preferred script editor, usually Visual Studio.

There is a new script named PlayerController in the Scripts folder in the Project window. The script is applied as a component beneath the Player Input component on the Player GameObject.

Follow the video or text instructions below to delete the Update function, add the InputSystem namespace, and add the OnMove function:

If you don’t already have the PlayerController script open, open it now.

Delete the entire Update function — you won’t need it.


Add the following line of code to the top of the script under the existing namespaces:

Below the Start function but before the final curly brace, add a new line and add the following code:

   void OnMove (InputValue movementValue)
   {
   
   }

Follow the video or text instructions below to set the movement vector, assign a new Rigidbody variable, and add a FixedUpdate function:

In the space inside the OnMove function, add the following line of code: 

Vector2 movementVector = movementValue.Get<Vector2>(); 

Above the Start function, add the following line of code to declare a new variable: 

Next, inside the Start function, add the following line of code to assign the variable’s value:

Create a new function called FixedUpdate below the Start function by adding the following code: 

   private void FixedUpdate() 
   {
   
   }

Follow the video or text instructions below to add force to the player, add x and y movement variables, assign those variables, finalize the AddForce call, and test your game.

In the FixedUpdate function body, add the following code: 

If the Editor shows an error, you can ignore it for now. 


Underneath the Rigidbody variable you created earlier, add two more private variables called movementX and movementY of type float:

private float movementX;
private float movementY;

In the OnMove function, add the following two lines of code:

movementX = movementVector.x; 
movementY = movementVector.y; 

In the FixedUpdate function, add the following new line at the top of the function: 

Vector3 movement = new Vector3 (movementX, 0.0f, movementY);

Revise the second line of code in FixedUpdate to include the movement variable: 

The Player GameObject should move, but slowly — you’ll fix that in the next step.

Follow the video or text instructions below to declare a new speed variable, multiply the force by speed, increase the speed in the Inspector window, and test the game:

Create a new public float variable at the top of the script: 

In the FixedUpdate function, revise the AddForce call to include the speed variable:

3.  Increase the speed in the Inspector window.

Since the speed is 0, the player won’t move.

In the PlayerController component, set the speed value to 10 and test your game.

The Player GameObject should now move at a more reasonable speed. 

You can adjust the speed up or down if you want.

If your script is not working as expected, below is an example of what your code should look like at this point. The comments have been added to make the code more readable. 


using System.Collections;
using System.Collections.Generic;
using Unity.VisualScripting;
using UnityEngine;
using UnityEngine.InputSystem;

public class PlayerController : MonoBehaviour
{
 // Rigidbody of the player.
 private Rigidbody rb; 

 // Movement along X and Y axes.
 private float movementX;
 private float movementY;

 // Speed at which the player moves.
 public float speed = 0; 

 // Start is called before the first frame update.
 void Start()
    {
 // Get and store the Rigidbody component attached to the player.
        rb = GetComponent<Rigidbody>();
    }
 
 // This function is called when a move input is detected.
 void OnMove(InputValue movementValue)
    {
 // Convert the input value into a Vector2 for movement.
        Vector2 movementVector = movementValue.Get<Vector2>();

 // Store the X and Y components of the movement.
        movementX = movementVector.x; 
        movementY = movementVector.y; 
    }

 // FixedUpdate is called once per fixed frame-rate frame.
 private void FixedUpdate() 
    {
 // Create a 3D movement vector using the X and Y inputs.
        Vector3 movement = new Vector3 (movementX, 0.0f, movementY);

 // Apply force to the Rigidbody to move the player.
        rb.AddForce(movement * speed); 
    }
}

Moving the Player

1. Overview

2. Add a Rigidbody to the Player

3. Install the Input System package

4. Add a Player Input component

5. Create a new script

6. Write the OnMove function declaration

7. Apply input data to the Player

8. Apply force to the Player

9. Fix the Player movement speed

10. Final script sample

Complete this tutorial