All content in this course uses:

Collect the collectible

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

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. 

Overview

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 

 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 

 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. 


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



 mode and try to collide with the collectible — notice what happens. Exit 

  Select the collectible object, then locate its 

 property. This transforms the physical collider into a trigger area.



 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 

Allow the player to go through the collectible

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 

 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 

 is only called if at least one of the objects involved has a 

 component attached to it. The player object already has a 

 method, but before the final curly bracket of the entire script, create some space by pressing 

 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. 



  Begin entering “OnTriggerEnter”. If your development environment supports it, you should see very helpful autocomplete suggestions.



.  Select or complete the OnTriggerEnter method in your script. 

It should look like this:

Any code that you put in between those two curly brackets will run when an object with a 

 component collides with the collectible. In this case, you want to make the collectible disappear, which you’ll do next.  

Add the OnTriggerEnter function

 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 

 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? 


 method where you plan to add new code, then press 

) 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.



  Write your comment, which should look like this:

Write a comment

In this step, you'll make the collectible disappear when the player interacts with it. You'll use the 

 method in Unity, which removes GameObjects from the scene. This will make it seem like the player has collected the object. 


) to add a new line beneath your comment.



  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:

  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 

 window, simulating that it has been collected by the player.

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



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

Destroy the collectible

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 

 — like puffs of smoke or mini explosions — are one of the most effective ways to provide this visual feedback.

In Unity, you can use 

 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.

 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. 



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

Inside prefab editing mode, you should see a 

 panel that allows you to restart and preview the particle effect.



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



  Exit prefab editing mode using the small back arrow at the top of the 

Explore particle effect options

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.


 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.



  Save your script and switch back to the Unity Editor.



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

You should now see the new 

 window window. You’ll notice that it has 

 assigned as its value. You need to tell Unity what prefab GameObject you actually want to use as your collection effect.



  To assign your chosen particle effect to the variable, locate your chosen VFX prefab in the 

 window. This links your VFX prefab with the variable in your script.

If you enter 

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

Create and assign a new variable for the particle

 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 

 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.


 command to make room for your new code.



 code as is shown below — feel free to also include the comment:   

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 

What position should we instantiate it at? My current position (

What rotation should it have when it’s instantiated? My current 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.



  Save your script, return to Unity, and enter 

 mode. 

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

Instantiate the particle

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.


 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.



 view gizmos to switch to the Top view to get a better perspective for arranging the collectibles. 



) to duplicate the collectible. 

The duplicate collectible will be at the same position — so you won’t see it in the 

 view, but you will see a copy appear in the 

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

 To ensure that the collectibles are evenly spaced, hold down 

) while you move the collectible. 

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



) 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.



  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!

Create an interesting path of collectibles

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 

 script needs to be: "When an object with a 

, 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 

  Select the player GameObject, open the 

  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. 



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 

 tag, then execute the code inside the brackets."



  Getting the brackets and capitalization exactly right is important. 



) 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. 



  Save your script and return to Unity.



 mode to test your scene. 

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

Restrict collisions to the player only

You now have a lot of collectible objects in your scene, and the 

 window is getting very cluttered. Take a moment to organize the 

 window, select the first collectible GameObject, then hold down the 

 key and select the last collectible object in your list to select all GameObjects in between.



  Right-click the selected objects and select 


This action creates a new GameObject with the collectible GameObjects indented as 

  Rename this new GameObject to something descriptive, like “Collectibles”. 


) to quickly rename it.

You can now expand and collapse that parent GameObject in the 

Declutter the Hierarchy

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. 

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

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

Unity Version 2022.3