Add a movement script

Create a rotating collectible

Collect the collectible

Programming Essentials: More things to try

Mission 4 Quiz

Unity Essentials: Programming Essentials Quiz

Add code so that a player character can explore a living room and gather collectibles. 

In this Mission, you’ll program a simple interactive experience where you control a character in a living room scene and move around to collect objects. 

You'll be able to choose from a variety of characters and collectible objects. In our example, we'll use a robot vacuum that maneuvers to pick up dirt around the room.

Programming Essentials

Unity Essentials Pathway

Master the basics of Unity with the Unity Essentials Pathway. Perfect for beginners, this free learning journey introduces game development, 3D content creation, and Unity's core tools. Start building today!

Unity Essentials Pathway - Learn Game Development for Beginners | Unity Learn

Unity Essentials is the perfect place to start for beginners to Unity. No previous experience is necessary.

New to Unity? This guided learning Pathway includes everything you need to get started.

Designed for anyone new to Unity, this guided learning journey is your first step toward creating confidently in the Unity Editor and bringing your visions to life. In this learning Pathway, you’ll design different rooms of a house, learning the essentials of one key skillset as you complete each room.

Unity Essentials

Unity Essentials: Install Unity

Open the Unity Essentials project

Explore the Editor Interface

Master 3D scene navigation

Pass the Scene view flying test

Design a mural in the Scene view

Editor Essentials: More things to try

Unity Essentials: Editor Essentials Quiz

Explore a playground scene and design a mural to get comfortable with the Unity interface.

This tutorial series introduces you to the essential skills of navigating the Unity Editor.

You'll learn to navigate 3D space in a playground scene, using Flythrough mode and tools like Move and Rotate to design a mural.

Once you master these skills, you’ll have the foundation required for confidently creating in Unity.

Editor Essentials

Add furniture to the kid’s room

Make a bouncy ball

Make a tower of prefab blocks

Adjust the lights, background, and camera angle

3D Essentials: More things to try

Unity Essentials: 3D Essentials Quiz

Design a kid's bedroom with a bouncing ball and a tower of collapsing building blocks.

In this tutorial series, you'll explore Unity's capabilities by designing a kid's bedroom scene with dynamic elements like a bouncing ball and a tower of blocks. You'll learn new skills in 3D navigation, object customization, and using Unity's physics system. 

You’ll also create prefabs, adjust lighting, and capture your scene with a camera. 

This foundational knowledge is vital to creating any type of Unity project.

3D Essentials

Create an immersive soundscape

Audio Essentials: More things to try

Unity Essentials: Audio Essentials Quiz

Add immersive sound to a kitchen scene with a variety of different types of audio.

In this Audio Mission, you will learn the fundamentals of implementing different types of audio into Unity scenes. You’ll learn how to set the tone with background music, how to add realism with sound effects, and even how to implement spatial audio in a 3D scene.

Audio Essentials

Set up a 2D room

Complete your 2D Puzzle Game

Add an animated pet

2D Essentials: More things to try

Unity Essentials: 2D Essentials Quiz

Create a top-down minigame similar to the 3D living room experience, but in 2D.

In this 2D Mission, you'll create a top-down 2D version of the interactive living room scene you created earlier. 

Just like in the 3D scene, you'll control a character, and try to collect all the objects in a room. By completing this scene, you'll learn how working in 2D is similar to working in 3D, but also how it’s different.

2D Essentials

Build your portfolio project

Publish to WebGL

Challenge: Add a bonus scene

Capture a video of your project

Share your project

Combine all of your scenes together into one cohesive portfolio project that you can share with others. 

It's time to collect all your good work together into a singular portfolio piece that you and others can play!

A portfolio, especially in the realm of real-time 3D (RT3D) and game development, is not just a collection of work, but a practical way of demonstrating your familiarity with essential tools and concepts. 

In this Mission, you will package all of your work from this Pathway into a single playable experience that you can easily share with others.


Publishing Essentials

bd467362-4b0c-4801-bca2-41a0f4b7b7e9:c3248763cd46

Overview

Add a collectible GameObject in front of the player

Create and apply a new Collectible script

Review the structure of the default script

Plan your rotation code

Add your first line of code to rotate the collectible

Reduce speed to a decimal float value

Declare new rotation speed variable

Review and proceed to next tutorial

Demonstrate basic Unity programming skills, such as identifying and editing methods, selecting the correct variable type, and comprehending simple scripts

Level 1 Code Comprehension

Joy Horvath

Instructional Designer

Control the execution of code with common logic structures 

Level 1 Application Scripting

GameObjects

lunaduranp

4.2.1 - Overview - VIDEO.mp4

4.2.2 - Add a collectible GameObject in front of the player - VIDEO.mp4

4.2.5 - Plan your rotation code - VIDEO.mp4

4.2.6 - Add your first line of code to rotate the collectible - VIDEO.mp4

4.2.7 - Reduce speed to a decimal float value - VIDEO.mp4

4.2.8 - Declare new rotation speed variable - VIDEO.mp4

4.2.3 - Create and apply a new Collectible script - VIDEO_U6_V2.mp4

Program your first line of code from scratch to make your collectible object rotate around its Y-axis. 

Namespaces

MonoBehaviour

Creating and Using Scripts

Event Functions

Variables and the Inspector

Games

Film

Automotive

Identify the purpose of common methods found in MonoBehaviours such as Start() and Update()

Define the major features of a script such as namespaces, classes, variables, and methods. 

Comprehend simple code by identifying essential programming structures

Identify common data types, including ints, floats, doubles, bools, strings, arrays, lists, and dictionaries

Devise comments that describe a given code block

Recognize naming conventions conforming to Unity standards, given a set of code blocks

Distinguish object-oriented code from data-oriented code

Distinguish an ECS (Entity Component System) class from any other type of class, given a code block containing a class definition

Interpret basic code in a Unity code base

Reduce redundancy and improve code's readability by correctly naming variables and methods

Describe common naming conventions including PascalCase and camelCase

Cultivate a code style that is efficient and easy to read

Create a GameObject component with a script 

Mission 4 - Programming Essentials

In the last tutorial, you copy and pasted code into a new script, which is a great way to start. In this tutorial, you’ll write your first line of code to make a collectible object rotate in the scene. These rotating collectible objects will be the things that your player character tries to gather throughout the living room scene. 

When you’re ready to get started, proceed to the next step. 

The first step is adding a collectible item in front of the player. You'll probably want to select a collectible prefab that makes sense with the character you've chosen:

The alien UFO could collect precious gemstones.

There are also a bunch of other interesting collectibles to choose from, so feel free to get creative with your selection. 


1.  In the Project window, navigate to _Unity Essentials > Prefabs > Collectibles.

2.  Drag and drop your chosen collectible prefab into the scene directly in front of the player. 

3.  Adjust the collectible’s position, rotation, and scale in the Scene view as needed to ensure that it's easily visible and reachable by the player. 

This will make testing as efficient as possible.

Tip:  You might want to adjust the position and rotation of the camera so that you can easily see the collectibles in front of the player in Play mode.

In this step, you’ll create a new empty script. This script, which you’ll name "Collectible", will govern the behavior of the collectible objects you've added to the scene. 


1.  In the Project window, navigate to the _Unity Essentials > Scripts folder you accessed in the previous tutorial. 

2.  Within the Scripts folder, right-click and select Create > MonoBehaviour Script.

3.  With the script’s name automatically highlighted, immediately rename this new script "Collectible". 

Just like last time, the spelling of the name is important because it becomes part of the script.
4.  Press Enter to save the script name. 

You'll see the code of the new blank script in the Inspector window.

Note:  If you make a typo in your script name or have to rename it for any reason, it will be easier to just delete it and create a new one with the correct name.

5.  In the Hierarchy, select the Collectible GameObject. 

6.  Drag and drop the Collectible script you just created from the Project window into an empty space of the Inspector window for the Collectible GameObject (such as the space around the Add Component button). 

Note that this is different from the technique you used earlier to apply a script, where you dragged it onto the object directly in the Scene view. There are usually a few different ways to do the same things in Unity!

Before you start coding, take a minute to review the structure of the default script you've just created. 

This might feel overwhelming at first, especially if you're new to programming. It's important to remember that understanding the nuances of scripting is a gradual process and it’s entirely normal to feel a bit daunted at this point! So don’t worry about that and trust that it will all slowly start to make sense over time. 


1.  In the Project window, double-click the Collectible script to open it in the script editor. 

2.  Locate the using statements at the top of the script, including “using UnityEngine;”. 

These lines link the script to the necessary libraries so that when you enter something like “Rigidbody,” the script knows what that means. 

3.  Beneath the using statements, locate the class declaration: 
public class Collectible : MonoBehaviour.

This defines the script as a public class named "Collectible" that inherits from Unity's MonoBehaviour class. MonoBehaviour is a required class for all GameObjects in Unity. This bit of code is what allows you to add your script as a component to a GameObject.

Don’t worry if this is still confusing at this point — it will slowly make more and more sense as you continue on.

4.  Locate the Start() function. 

This function is executed once at the beginning of the game. 

5.  Locate the Update() function. 

Unity runs this function once per frame. 

Games typically run at 30-60 frames per second, so any code within this function will be executed many times continuously throughout the game, making it suitable for ongoing actions and animations. This is where you’ll put your rotation code so that the collectible will rotate continuously. 

A new Unity script with the following sections highlighted with a box: the using statements, the class declaration, the Start function, and the Update function. 

Before writing your first line of code, let’s take a moment to understand what you’re actually trying to do in your code. You’ll experiment in the Scene view to visualize this.


1.  Select the collectible object and frame it in the Scene view so you have a good view of it. 

2.  At the top of the Scene view, make sure you’re using the Local coordinate system instead of the Global system so that you’ll be able to see the orientation of the collectible changing as it rotates. 

3.  In the Inspector window, in the Transform component, locate the Rotation coordinates. Click and drag the label Y right and left to change the Y-axis rotation. 

Watch the demo video again very closely if you’re still not sure how to do this.

Tip:  If you hold down the Shift key while you click and drag the value, the value will change more quickly. 

Observe how the object rotates in the Scene view. This visual experiment helps you see the effect of rotation values on your object. This is the effect you want to achieve in your script: you want to increase the Y rotation value in the Transform component continuously over time. 

In the next step, you’ll add the code that rotates the collectible around the Y-axis continuously.

It's time to add continuous rotation from your Collectible script. You'll do this by manipulating the object's Transform component, which controls the object's position, rotation, and scale in the scene. 

Specifically, you'll use the transform.Rotate method, a built-in Unity function that makes an object rotate in three dimensional space. For a simple rotation effect, you'll change the Y value, which makes the object rotate around its vertical axis.

When you put this rotation code in the Update function, the collectible will rotate a little bit each frame, making it appear to smoothly, continuously rotate. 


1.  Open the Collectible script in the script editor.

2.  Put your cursor inside the Update() method, between the sets of curly brackets. 

It can be helpful to add a few new lines using the Enter (macOS: Return) key to give yourself a bit of space before you add your new code. 

The extra space won’t change the functionality of the code, but it can make your code easier to read.

3.  Write the following line of code inside the Update function, between the opening and closing curly brackets: 

 transform.Rotate(0, 1, 0); 

Important: Don’t forget to add the semicolon at the end of the line of code. 

This line instructs Unity to rotate the collectible object 1 degree around the Y-axis in each frame, creating a continuous rotation effect.

4.  Save the script by pressing Ctrl+S (macOS: Cmd+S) or by selecting File > Save from the main menu of the script editor. 

5.  Back in the Unity Editor, enter Play mode to see the collectible object rotating continuously.

Tip: During Play mode, you can switch to the Scene view tab, which will allow you to get a close-up view of your collectible as the application is running.  

6.  Remember to exit Play mode when you’re done testing! 

You might notice that the collectible rotates really quickly. However, if you try to reduce the value from 1 to 0.5 in your script, you'll get an error in your code, indicated by a red underline. 

In C#, decimal numbers are treated as float values.
A float, short for "floating point number", is a data type that can handle decimals. 

Data types in programming specify the type of a value and how the computer interprets this value. For instance, integers for whole numbers, floats for decimal numbers, and strings for text. 

When you use float values in C#, you need to explicitly indicate it's a float by putting an “f” at the end of the number. 


1.  Reopen the Collectible script in your script editor.

2.  Modify the rotation line in the Update() method to transform.Rotate(0, 0.5f, 0);.
 
This change reduces the rotation speed to half a degree per frame. 

When entering the decimal value 0.5, make sure to add “f” at the end (0.5f). Try temporarily removing the “f” to see the error in your code.

3.  Save the script and return to the Unity Editor. Play your scene to observe the slower rotation of the collectible. 

In this step, you will enhance the flexibility of the rotation behavior by introducing a public variable to your script.

A variable in programming is just a named piece of data that can vary. When you declare a public variable for rotation speed, you'll allow yourself, and anyone else who works on this project in Unity, to easily adjust the rotation rate directly from the Inspector window without the need to modify the script. 

This practice is an example of efficient game programming.


1.  Open the Collectible script in your script editor.

2.  Above the Start() method, but after the first opening curly bracket of your script, use the Enter (macOS: Return) key to add a few empty lines to make some space for yourself to type. 

Important:  Pay close attention to the demo video to see where to put this code. Putting it in the wrong section of your script will cause errors. 

3.  Declare a new public float variable before the Start method by adding the line: 

 public float rotationSpeed;

This creates a public variable named rotationSpeed of type float. The word "public" (as opposed to "private") makes this value editable in the Inspector window. 

Using a lowercase letter for the first word, but uppercase letters at the start of all subsequent words is known as camelCase, and is a common practice when naming variables. It’s called camelCase because it kind of looks like a camel from the side, with humps at the center of the word. 

4.  Now, replace the hard-coded rotation value in the Update() method with this new variable you just created: 

     transform.Rotate(0, rotationSpeed, 0);

5.  Save the script and switch back to the Unity Editor. In the Inspector window, you'll now see the rotationSpeed variable in the Inspector window when you select the collectible object, which is set to zero by default. You’ll also notice that Unity has taken your camelCase rotationSpeed variable and changed it to Rotation Speed in the Inspector window for improved readability. 

6.  In the Inspector window, set the Rotation Speed value to a number like 0.5 to control the speed of rotation. Edit the value to the rotation speed you like the best.

Now, if you ever want to adjust that value in the future, you don’t need to open a script! You can make the change right there in the Inspector window. 

Note:  Remember to save your scene after exiting Play mode.

Congratulations on writing your first line of code to make the collectible rotate about the Y-axis! 

Here are some of the things you learned along the way:

Explain the using statements at the top of a Unity script.

Identify a class declaration in a script.

Explain the MonoBehaviour class in Unity scripts.

Explain the Start() and Update() functions in a Unity script.

Call a transform function in the Update() method to transform a GameObject over time.

Apply correct data types in code, including integers and floats.

Declare new custom variables in a script.

Explain how public variables in a script behave in Unity.

Describe common naming conventions including PascalCase and camelCase.

Apply correct naming conventions to variables and methods.


Proceed to the next tutorial where you'll finalize the living room functionality. You’ll add more code that will allow the player to pick up the collectible object. and then you’ll arrange more collectibles throughout the room. 

Create a rotating collectible

1. Overview

2. Add a collectible GameObject in front of the player

3. Create and apply a new Collectible script

4. Review the structure of the default script

5. Plan your rotation code

6. Add your first line of code to rotate the collectible

7. Reduce speed to a decimal float value

8. Declare new rotation speed variable

9. Review and proceed to next tutorial

Complete this tutorial