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

ca1ca6b9-4131-4aef-a5ea-9834403da399:e70aa6966b5f

Overview

Allow the player to go through the collectible

Add the OnTriggerEnter function

Write a comment

Destroy the collectible

Explore particle effect options

Create and assign a new variable for the particle

Instantiate the particle

Create an interesting path of collectibles

Restrict collisions to the player only

Declutter the Hierarchy

Review and proceed to next tutorial

Control the execution of code with common logic structures 

Level 1 Application Scripting

Joy Horvath

Instructional Designer

GameObjects

lunaduranp

4.3.1 - Overview - VIDEO.mp4

4.3.3 - Add the OnTriggerEnter function - VIDEO.mp4

4.3.4 - Write a comment - VIDEO.mp4

4.3.5 - Destroy the collectible - VIDEO.mp4

4.3.8 - Instantiate the particle - VIDEO.mp4

4.3.6 - Explore particle effect options - VIDEO.mp4

4.3.11 - De-clutter the Hierarchy - VIDEO.mp4

4.3.7 - Create and assign a new variable for the Particle - VIDEO.mp4

4.3.2 - Allow the player to go through the collectible - VIDEO.mp4

4.3.9 - Create an interesting path of collectibles - VIDEO.mp4

4.3.10 - Restrict collisions to the Player only - VIDEO.mp4

 Make each collectible disappear and spawn a cool particle effect when the player gets it. 

Event Functions

Instantiating Prefabs at run time

Debug C# code in Unity

Games

Film

Automotive

Implement simple logic in code by using if and if-else statements

Control the execution of code by using logical operators such as AND and OR in conditional statements

Control how many times certain lines of code run by using for loops, foreach loops, and while loops

Control the order and timing of executed code by using coroutines

Control the execution of code by using switch statements

Modify the values of numeric variables by using mathematical operators

Control the execution of code with common logic structures

Select the appropriate common Unity methods to use, e.g., Awake, Start, Update, FixedUpdate, Collision, and Trigger Events, given a desired feature to code

Achieve a desired result by using Unity API methods, given Unity’s script documentation

Achieve a desired result with different parameters by using various method overloads

Distinguish a correct use of any given Unity API method from an incorrect use

Control or trigger the state of components, such as an Animator Controller, Light, AudioSource, or User Interface element by using appropriate methods

Construct an input listener, given a scenario where a specific type of input is required

Print a message consisting of concatenated strings and variable values to the console by using Unity's Debug.Log method

Compose scripts that utilize various APIs

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 previous tutorial, you wrote your first line of code to make a collectible object rotate in the scene. In this tutorial, you’ll complete the interactive living room scene with more code that allows the player to pick up the collectible object, rewarding them with a satisfying visual effect. You’ll also add more collectibles throughout the room to complete the scene.

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

Right now, the collectible is like an immovable rock — it won’t budge when the player collides with it at full speed, and it even knocks the player off its course! You need to set up the collectible so that the player can pass through it without any visible physical collision or bump. 

You can achieve this with the Is Trigger property of the Collider component. When you tell a collider component to act as a trigger instead of a physical collider, it will no longer have a solid barrier, but it can still detect entry by the player or other GameObjects. 

A trigger collider makes an object act more like a cloud. Even though it looks solid, an airplane can still pass right through it, and the pilot knows when they’ve gone through it. 


1.  Make sure that the collectible is positioned in your scene so that the player can run into it.

2.  Enter Play mode and try to collide with the collectible — notice what happens. Exit Play mode when you’re done testing. 

3.  Select the collectible object, then locate its Collider component.

4.  In the Collider component, enable the Is Trigger property. This transforms the physical collider into a trigger area.

5.  Enter Play mode to test it again. Verify that the player can move through the collectible without any physical resistance. 

The collectible still doesn't disappear when the player moves over it. You’ll work on that next.

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

In this step, you’ll write code to detect when the player makes contact with the collectible. You’ll achieve this in your script using the OnTriggerEnter function, a special Unity function that is called when one object enters a trigger collider zone of another object. 

It's important to note that OnTriggerEnter is only called if at least one of the objects involved has a Rigidbody component attached to it. The player object already has a Rigidbody component, so you’re all set!


1.  Reopen the Collectible script in your script editor.

2.  After the ending curly bracket of the Update method, but before the final curly bracket of the entire script, create some space by pressing Enter (macOS: Return) a few times.

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.  Begin entering “OnTriggerEnter”. If your development environment supports it, you should see very helpful autocomplete suggestions.

4.  Select or complete the OnTriggerEnter method in your script. 

It should look like this:

private void OnTriggerEnter(Collider other) {

}

Any code that you put in between those two curly brackets will run when an object with a Rigidbody component collides with the collectible. In this case, you want to make the collectible disappear, which you’ll do next.  

Comments are non-executable lines in your code that serve as notes or explanations. They are crucial for maintaining clear and understandable code, especially when you're working on complex projects or with a team. 

Here, you'll use comments as pseudo code, a practice where you outline your code's intended logic in plain language before you write the functional code. It's a way to plan and clarify your thoughts, and make the coding process go smoother. 

In C#, comments are marked with “//”, and anything following these two slashes on the same line is ignored when the code runs. 

The default template Unity script that you get when you create a new script already has a couple of comments — did you notice them? 


1.  In your script, navigate to the OnTriggerEnter method where you plan to add new code, then press Enter (macOS: Return) a few times after the opening curly bracket to make some space.

In this case, you’ll write the comment, “Destroy the collectible”, since that’s what you want to do when the player enters its trigger zone.

2.  Write your comment, which should look like this:

private void OnTriggerEnter(Collider other) {
       // Destroy the collectible
}

In this step, you'll make the collectible disappear when the player interacts with it. You'll use the Destroy method in Unity, which removes GameObjects from the scene. This will make it seem like the player has collected the object. 


1.  Inside the OnTriggerEnter method, press Enter (macOS: Return) to add a new line beneath your comment.

2.  Begin to enter “Destroy“ and notice that your code editor may provide autocomplete suggestions. Then complete the line of code:

The “GameObject” here refers to the GameObject the script is attached to, which in this case, is your collectible. Also, note that “gameObject” starts with a lowercase letter here (camelCase).

Your code should look like this:

private void OnTriggerEnter(Collider other) {   
       // Destroy the collectible
       Destroy(gameObject);
}

3.  Save the script, return to Unity, and enter Play mode. 

You'll see that when the player collides with the collectible, it disappears from the scene and from the Hierarchy window, simulating that it has been collected by the player.

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

Tip: If the behavior does not work, double-check that you saved your script.

You probably noticed that collecting the object was not very satisfying or obvious; you could barely tell it was collected!

When the player accomplishes something, they should get some kind of visual feedback to make that clear. Simple Visual Effects (VFX) — like puffs of smoke or mini explosions — are one of the most effective ways to provide this visual feedback.

In Unity, you can use particle systems to simulate complex visual effects such as fire, smoke, or a burst of sparks. In this step, you’ll select a particle system to provide visual feedback for your collectible.

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

This folder contains pre-made 2D and 3D visual effects that you can use in your scene. You’ll use the non-2D effects for this project. 

2.  Double-click the various 3D particle system prefabs to preview them in prefab editing mode. 

Inside prefab editing mode, you should see a Particles panel that allows you to restart and preview the particle effect.

3.  Take note of which one you want to use for your collectible — you’ll actually make it appear in the following steps.

4.  Exit prefab editing mode using the small back arrow at the top of the Hierarchy window.

Variables store data that you can reference and manipulate in your code. For example, you made a float variable for the rotation speed of your collectible in the previous tutorial.  

Variables aren’t just limited to numbers, though. They can be any data type — you can even have GameObjects variables!

In this step, you'll create a variable of the type GameObject to reference your chosen particle effect prefab. Later on, you’ll be able to reference this variable to spawn your particle effect in the scene.


1.  Open your Collectible script in your script editor.

2.  Below your rotationSpeed variable near the top of the script, add a new line that declares a new public variable of type GameObject:

You can name the variable whatever you want, but something like “onCollectEffect” makes sense. This variable will hold the reference to your particle effect prefab.

3.  Save your script and switch back to the Unity Editor.

4.  In the Unity Editor, select the collectible GameObject that your script is attached to. 

You should now see the new On Collect Effect variable in the Inspector window window. You’ll notice that it has None assigned as its value. You need to tell Unity what prefab GameObject you actually want to use as your collection effect.

5.  To assign your chosen particle effect to the variable, locate your chosen VFX prefab in the Project window, then drag the prefab from the Project window onto the On Collect Effect variable box in the Inspector window. This links your VFX prefab with the variable in your script.

If you enter Play mode now, the particle effect still won’t generate — you’ll add the code to do that next. 

Instantiating an object in Unity means creating a copy of it during runtime (while the application is running); you’re making a new instance of that prefab in your scene. 

Just like the transform.Rotate method you used earlier required a rotation value for the X, Y, and Z axes, the Instantiate method also requires certain information to execute, separated by commas. Specifically, you need to specify the following information:

In this step, you'll instantiate your chosen particle effect when the player collides with the collectible.


1.  Inside the OnTriggerEnter method, press Enter (macOS: Return) after the Destroy command to make room for your new code.

2.  Add the Instantiate code as is shown below — feel free to also include the comment:   

// instantiate the particle effect
Instantiate(onCollectEffect, transform.position, transform.rotation);

Keep in mind that since this code defines properties of the collectible, "transform" refers to the transform (position, scale, rotation) of this particular collectible GameObject. With that in mind, here’s how you can interpret the code above:

Which object do we want to instantiate? The onCollectEffect. 

What position should we instantiate it at? My current position (transform.position).

What rotation should it have when it’s instantiated? My current rotation (transform.rotation).

transform.position and transform.rotation refer to the collectible’s position and rotation since this script is attached to the collectible object. 

Don’t worry if this is still confusing at this point. It’ll take repetition and time before you’re fully comfortable. This is part of the process.

3.  Save your script, return to Unity, and enter Play mode. 

You'll see the particle effect appear when you collide with the collectible. This visual feedback is much more satisfying! 

With your collectible now completely functional, you’re ready to populate your scene with more of them. We'll provide you with a few pro tips for efficiently creating a straight, evenly-spaced path of objects in your scene.


1.  In the Scene view, make sure you are using Global coordinates so that you can move objects in a straight line relative to the world’s coordinates, regardless of which way each object is facing.

2.  In the Hierarchy window, double-click the 03_Living_Room GameObject to frame it, then use the Scene view gizmos to switch to the Top view to get a better perspective for arranging the collectibles. 

3.  Select the Move tool, then select your collectible.

4.  Press Ctrl+D (macOS: Cmd+D) to duplicate the collectible. 

The duplicate collectible will be at the same position — so you won’t see it in the Scene view, but you will see a copy appear in the Hierarchy window.

5.  To move the duplicated collectible along a specific axis (X, Y, or Z), click and drag one of the arrows of the Move tool.

6.  To ensure that the collectibles are evenly spaced, hold down Ctrl (macOS: Cmd) while you move the collectible. 

This enables snapping, so that you can place the collectible at fixed increments along the chosen axis.

7.  Repeat the process: duplicate (Ctrl+D (macOS: Cmd+D), then move (drag while holding Ctrl or Cmd) to create a series of collectibles, forming a path or pattern.

Make an interesting path through the environment so that the user of your game will explore and interact with the entire living room.

8.  Test your living room scene in Play mode and try to collect all the collectibles — it should be pretty satisfying gameplay now that you have some visual feedback on each collision!

When you spread collectibles around the room, you may have noticed something strange: collectibles disappear when they collide with one of the chairs! If you haven’t already seen the problem, try putting one of the chair’s legs or the couch on top of one of your collectibles, then enter Play mode. You’ll see the chair trigger the destruction of the collectible!

To fix this, you'll need to adjust the logic in the code so that only the player triggers these events. The logic in the Collectible script needs to be: "When an object with a Rigidbody component collides with me, IF that object is the player, then destroy myself and spawn a particle effect."

To add this logic, you’ll use an if-statement to check if a certain condition is true, and if that condition is true, then continue to execute the code. 

You’ll also use a feature in Unity called tags to identify the player GameObject. 


1.  Select the player GameObject, open the Tag dropdown at the top of the Inspector window, and select Player to apply that tag.

2.  In the Collectible script, use the Enter (macOS: Return) key to add some space above the Destroy command for your new if-statement. 

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.  Add the following if-statement code:

Remember, this code defines properties of this collectible, so “other” refers to another object that has collided with this one. With that in mind, here’s how you can read the code above:

"If the “other” GameObject that collided with me has the Player tag, then execute the code inside the brackets."

Important:  Getting the brackets and capitalization exactly right is important. 

4.  Select the Destroy and Instantiate code below your if-statement, then use Ctrl+X, Ctrl+V (macOS: Cmd+X, Cmd+V) to cut and paste the code to the space between the curly brackets of your new if-statement. 

Now that code will only run if the if-statement’s condition is met. 

5.  Save your script and return to Unity.

6.  Enter Play mode to test your scene. 

Only the player should be able to trigger the collection effect now. 

You now have a lot of collectible objects in your scene, and the Hierarchy window is getting very cluttered. Take a moment to organize the Hierarchy using an empty parent GameObject. 


1.  In the Hierarchy window, select the first collectible GameObject, then hold down the Shift key and select the last collectible object in your list to select all GameObjects in between.

2.  Right-click the selected objects and select Create Empty Parent.
This action creates a new GameObject with the collectible GameObjects indented as child GameObjects.

3.  Rename this new GameObject to something descriptive, like “Collectibles”. 
Tip:  When an object is selected in the Hierarchy window or the Project window, you can press F2 (macOS: Return) to quickly rename it.

You can now expand and collapse that parent GameObject in the Hierarchy to keep things nice and tidy. 

Congratulations on completing your interactive living room scene by setting up collision detection for your collectible and triggering VFX feedback. 

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

Set up a collider as a trigger instead of a physical boundary.

Apply the OnTriggerEnter() function to detect collisions with other objects.

Devise comments that describe a given block or line of code.

Apply the Destroy() function to remove objects from a scene.

Code quickly using the autocomplete feature of the IDE.

Explain how visual effects (VFX) can be used to give the user visual feedback.

Declare a variable with the data type of GameObject.

Apply the Instantiate() function to spawn prefab instances in a scene.

Apply snapping with the Move tool to align and evenly space out GameObjects.

Apply if statements to control the logic and flow of a script.

Apply tags to GameObjects in order to identify them in a script.


Proceed to the next tutorial, which includes optional challenges to further develop your skills, explore new concepts, and improve your project. 

Collect the collectible

1. Overview

2. Allow the player to go through the collectible

3. Add the OnTriggerEnter function

4. Write a comment

5. Destroy the collectible

6. Explore particle effect options

7. Create and assign a new variable for the particle

8. Instantiate the particle

9. Create an interesting path of collectibles

10. Restrict collisions to the player only

11. Declutter the Hierarchy

12. Review and proceed to next tutorial

Complete this tutorial