Set up your 2D game world

Make a flying obstacle prefab

Random obstacle size, direction, and speed

Steer the player

Add a scoring system

Restart the game with a bang

 Optional bonus features

Build and publish to web

In this course, you’ll build a 2D game in Unity — starting from a completely blank project with no assets provided, you’ll create the entire game from start to finish. In the game, you fly a simple triangle-shaped ship using mouse clicks (or screen taps on mobile). Your goal: stay alive for as long as you can by dodging flying obstacles while your score increases over time.

Along the way, you’ll learn the fundamentals of working in 2D, from navigating the Scene view to coding simple gameplay interactions. You’ll also explore key Unity systems like a user interface (UI), particle effects, audio, and publishing. By the end, you’ll not only have a complete, playable game, but you’ll also have the skills to start building your own original 2D projects.

2D Beginner Game: Sprite Flight

990d5483-f1bb-5c70-a8cb-b7516530503f:EJWbNZ6QA41b2p9CvJ7Nf8

Overview

Add a basic particle system

Edit Emission, Shape, and Randomization

Make the explosion a prefab

Trigger the explosion from your script

Add and style the Restart button

Hide the Restart button at start

Show the Restart button on collision

Reload scene on click

Final script sample

Optional: More things to try

Next steps

Control the execution of code with common logic structures 

Level 1 Application Scripting

Joy Horvath

Instructional Designer

Create user interfaces in an application and write code to implement defined functionality.

Programming User Interfaces

Write code to implement systems and structures for complex projects.

Level 2 Application scripting

Create simple particle systems to add dynamic environmental and gameplay effects to your scenes.

Beginner Particles and Visual Effects

ElizabethMidgley

GameObjects

lunaduranp

6.1 - Overview.mp4

6.3 - Edit Emission, Shape, and Randomization.mp4

6.4 - Make the explosion a prefab.mp4

6.5 - Trigger the explosion from your script.mp4

6.6 - Add and style the Restart button.mp4

6.7 - Hide the Restart button at start.mp4

6.8 - Show the restart button on collision.mp4

6.9 - Reload scene on click.mp4

6.10 - Expert - Add impact effects when obstacles collide.mp4

6.2 - Add a basic particle system.mp4

In this tutorial, you’ll add a particle explosion that triggers when the player is destroyed, then use UI Toolkit to create a Restart button that reloads the scene — giving your game a clean and satisfying game-over flow.

Gaming

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

Configure UI components to be used with scripts. 

Arrange UI components on the canvas according to a defined layout using anchors, pivots, and groups. 

Organize UI components using optimization best practices such as using nested canvases. 

Configure UI components to be used with scripts.

Arrange UI components on the canvas according to a defined layout using anchors, pivots, and groups.

Organize UI components using optimization best practices such as using nested canvases.

Create user interfaces as defined in design documents.

Call the appropriate start-up methods in the initialization sequence of the app

Save user data in a the shutdown sequence of the app

Load the next scene when triggered by an event

Create the scene flow in an application state

Set up a new Particle System in the scene

Play, pause, stop, and restart a particle system in Scene view by using the Particle Effect window

Create a single burst of particles, rather than a continuous emission over time by using the Bursts section of the Emission module

Explain how individual Particle Systems can be combined to create more complex effects

Locate the Main module of a Particle System

Recall the three modules enabled by default in a Particle System: Emission, Shape, and Renderer

Configure a Particle System's main properties, such as lifetime, size, and max particles by modifying the Main module

Control the location and initial direction of particles by modifying the Shape module

Control the rate and timing of particles by modifying the Emission module

Control the appearance of individual particles by modifying the Renderer module

Add randomness to a Particle System by using the Random Between Two Constants feature

Change the color of a particle over its lifetime by using the gradient editor and the Color Over Lifetime module

Change the size of a particle over its lifetime by using the curve editor in the Size Over Lifetime module

Produce environmental and burst effects by configuring Unity's Particle System object

 Employ prefabs in order to manage the GameObjects in a scene or project 

Manage GameObjects with prefabs

To get started with your explosion effect, you’ll add a basic particle system using the Built-in Particle System, Unity's  visual effects tool. In this initial step, you’ll set up a simple burst of particles then in the following step, you’ll refine that burst to look like a massive explosion.

Right-click in the Hierarchy window and select Effects > Particle System.

Rename the new GameObject “ExplosionEffect”.

With the ExplosionEffect GameObject selected, in the Inspector window, set its Transform component’s Position property to X = 0, Y = 0, and Z = 0.

Note: When you create a particle system, Unity also opens a Particles overlay in the Scene view that lets you play, pause, and restart the effect to preview it live.

With the ExplosionEffect GameObject selected in the Hierarchy window, make the following changes in the Inspector window:

Disable Looping — you only want the effect to emit particles once in a burst.

Reduce Duration to 0.25 — This is how long the system will emit particles.

Reduce Start Size to 0.1 — This will make the particles a more appropriate size.

Tip: You can hover your cursor over any property label in the Inspector window to view a tooltip that briefly explains what it does — this is useful when exploring new particle system settings.

In the Particles overlay, select Restart to see the updated effect.


You now have a short, contained burst of a few particles — this is a good base for your explosion.

Now that you’ve got a basic particle system in place, you’ll enhance it by adjusting how the particles are emitted and how they spread. In this step, you’ll create a short burst of particles, change the emission shape from a cone to a sphere, and add randomness to make the explosion look more dynamic.

With the ExplosionEffect GameObject selected in the Hierarchy window, select the Emission section in the Inspector window to expand it.

Select the Add (+) button under the Bursts property to add a new burst.

Note: A burst emits all the particles at once, instead of gradually over time — perfect for explosions.

2.  Change the shape of the particle spread:

Change the Shape property from Cone to Sphere.

In the Explosion Effect section, open the Start Size dropdown and select Random Between Two Constants.

Set the range to something like (0 to 0.25).

Tip: Small, randomized particles help make the explosion look more organic and less uniform.

After this step, your explosion will feel much more satisfying — a quick, randomized burst that’s ready to be initiated whenever the player is destroyed.

Now that your explosion looks the way you want, you’ll turn it into a prefab — a reusable GameObject template. Prefabs are essential when you want to create and reuse the same GameObject multiple times in your game, like spawning an explosion every time the player is destroyed.

Drag the ExplosionEffect GameObject from the Hierarchy window into the Prefabs folder in the Project window.

You’ll see the name turn blue in the Hierarchy window, indicating the ExplosionEffect GameObject is now an instance of a prefab.


After confirming the prefab was created, delete the ExplosionEffect GameObject from the Hierarchy window — you’ll spawn it from code later.

Note: When a GameObject is saved as a prefab, you can safely delete it from the scene. You’ll still be able to access and instantiate it during gameplay using scripts.

Now that your explosion is a prefab, you’ll trigger it from code when the player is destroyed. You’ll use Unity’s Instantiate() method to create a copy of the prefab at the Player GameObject’s position right before it disappears. To do this, you'll add a reference to the prefab in your script and assign it using the Inspector window.

1.  Add a public reference to the ExplosionEffect prefab:

Near your other variable declarations, add the following line of code:

Note: Declaring the variable as public makes it visible in the Inspector window so you can assign the prefab without needing to find it in code.

2.  Instantiate the ExplosionEffect prefab when the Player GameObject is destroyed:

Inside your OnCollisionEnter2D() method, add the following line of code before the Destroy(gameObject); line:

Instantiate(explosionEffect, transform.position, transform.rotation);

Instantiate() creates a copy of the ExplosionEffect prefab.

transform.position places the ExplosionEffect prefab where the Player GameObject is, and transform.rotation sets its rotation to match the Player GameObject’s rotation. However, since the particle system is in the shape of the sphere, its rotation actually doesn’t matter.


3. Assign the prefab in the Inspector window and test:

In the Hierarchy window, select the Player GameObject.

In the Inspector window, locate the PlayerController script component.

Drag the ExplosionEffect prefab from the Project window into the Explosion Effect box.

Enter Play mode to test your explosion. 


Tip: If you forget this step, the explosion won’t appear — Unity can’t instantiate a prefab it doesn’t know about.

The explosion effect now plays when the Player GameObject is destroyed — giving instant visual feedback and making the collision event feel more complete.

After the player explodes, you’ll want to give them a clear, easy way to try again. In this step, you’ll add a Restart button to your existing UI document, position it near the center of the screen, and apply some basic styling to make it visible and clickable.

In the Project window, double-click the UILayout asset to open it in the UI Builder window.


From the Library window, drag a Button element into the Hierarchy window.

The Button element will appear centered and stretched across the screen in the Viewport window.


With the new Button element selected, go to the Inspector window.

Set the button’s Name to “RestartButton”.

Set the button’s Text to “Restart”.

Note: The name you assign here (RestartButton) is what your script will use to reference this element — make sure it's spelled correctly.

4.  Apply styling to position and format the button:

With the RestartButton button still selected, use the foldout (triangle) to expand the Inlined Styles section in the Inspector window.

Use the foldout (triangle) to expand the Align section, then set the Align Self property to Center.

Use the foldout (triangle) to expand the Position, set the Position Mode property to Absolute, change the Top offset from px to %, then set the Top offset value to 50%. This will position the top of the button 50% down the screen.

Adjust the Font Size and Color properties (under the Text section) and the Color property (under the Background section) as you like to make the button more readable.

Tip: Select Fit Viewport in the top bar of UI Builder window to help preview the layout if elements appear off-screen.

Save your UI document and return to the Unity Editor. Your Restart button will now be styled and centered.

The Restart button is now part of the UI, but it shouldn’t be visible until the Player GameObject explodes. In this step, you’ll reference the button in your script and hide it at the start of the game by changing its display style in code.

In your PlayerController script, add the following line of code with your other UI variables:

2.  Find the button using its name in Start():

Inside the Start() method, add the following line of code after retrieving scoreText:

restartButton = uiDocument.rootVisualElement.Q<Button>("RestartButton");

This uses Unity’s query system to find the UI element by its type (Button) and name (RestartButton).

Make sure the spelling matches exactly with what you set in the UI Builder window.



3.  Hide the button at the start of the game:

Still in Start(), add the following line of code after assigning restartButton:

restartButton.style.display = DisplayStyle.None;

Note: Setting the display style to None removes it from the layout completely — it won’t take up any space or be visible.

Save your script and test your game. The Restart button should now disappear when the game starts.

Now that your Restart button is connected and hidden at the start, it's time to reveal it when the player is destroyed. You'll do this by updating its display style inside the same method that handles collisions — right after playing the explosion effect.

1.  Show the button in OnCollisionEnter2D():

Inside the OnCollisionEnter2D() method (just after the explosion is instantiated), add the following line of code:

restartButton.style.display = DisplayStyle.Flex;

DisplayStyle.Flex makes the button visible and allows it to occupy space in the UI layout. 

The word "Flex" comes from flexbox layout, a system used in UI Toolkit (and CSS) where elements are laid out in a flexible row or column — so DisplayStyle.Flex simply means "display this element using standard flexible layout behavior."

Save your script and enter Play mode in Unity. The Restart button will now appear with the explosion effect.

Now that your Restart button appears on game over, it’s time to make it functional. In this step, you’ll write a method that reloads the current scene and hook it up to the button’s click event so players can start fresh with a single click of the button.

In your PlayerController script, add the following method inside your class before the final closing curly brace (}):

void ReloadScene()
{
SceneManager.LoadScene(SceneManager.GetActiveScene().name);
}

This is your first time writing a custom function — a block of code that runs only when it’s called.

The keyword void means the function doesn’t return a value — it just performs an action. If that’s confusing, don’t worry — you’ll learn more about return types later. For now, just know that “void” is what you use when you’re not expecting any data output.

The name ReloadScene is something you choose — you can name it anything, but clear names help others (and future you) understand what it does.

Inside the function, you're calling Unity's built-in scene load command, using the current scene’s name to reload it.



2.  Add the SceneManager library (if needed):

If SceneManager is underlined or causes an error, add the following line of code to the top of your script:

Tip: Some IDEs (like Visual Studio or Rider) may add this automatically as you type the code. You can also hover over the red underline and use a suggested import to resolve it.


In your Start() method, after assigning restartButton, add the following line of code:

This connects the button’s clicked event to your ReloadScene() method, so the scene reloads when the player selects the Restart button.

The += symbol is the same one you used earlier to increment elapsedTime. Here, it means "add this method to the list of things that happen when the Restart button is selected." You're not adding numbers — you're adding functionality.

After this step, selecting the Restart button will reset the game and return everything to its initial state — completing the core game loop.

If you have any errors in your code or you just want to make sure your script matches exactly what has been taught up to this point, feel free to reference or copy the final code sample below. 

using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.SceneManagement;
using UnityEngine.UIElements;

public class PlayerController : MonoBehaviour
{
    private float elapsedTime = 0f;
    private float score = 0f;

    public float scoreMultiplier = 10f;
    public float thrustForce = 1f;

    Rigidbody2D rb;

    public UIDocument uiDocument;
    private Label scoreText;
    private Button restartButton;

    public GameObject explosionEffect;
        
    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
        scoreText = uiDocument.rootVisualElement.Q<Label>("ScoreLabel");
        restartButton = uiDocument.rootVisualElement.Q<Button>("RestartButton");
        restartButton.style.display = DisplayStyle.None;
        restartButton.clicked += ReloadScene;

    }

    // Update is called once per frame
    void Update()
    {
        elapsedTime += Time.deltaTime;
        score = Mathf.FloorToInt(elapsedTime * scoreMultiplier);
        scoreText.text = "Score: " + score;
        
        if (Mouse.current.leftButton.isPressed) {
            
            // Calculate mouse direction
            Vector3 mousePos = Camera.main.ScreenToWorldPoint(Mouse.current.position.value);
            Vector2 direction = (mousePos - transform.position).normalized;
            
            // Move player in direction of mouse
            transform.up = direction;
            rb.AddForce(direction * thrustForce);

        }
        
    }

    void OnCollisionEnter2D(Collision2D collision)
    {
        Destroy(gameObject);
        Instantiate(explosionEffect, transform.position, transform.rotation);
        restartButton.style.display = DisplayStyle.Flex;
    }

    void ReloadScene() {
        SceneManager.LoadScene(SceneManager.GetActiveScene().name);
    }

}

Try these optional activities to challenge yourself, build your skills, and improve your project.

Each challenge is tagged as Easy, Medium, or Expert difficulty so that you know what to expect. You can complete one, all, or none of them — it’s totally up to you. If you’re not interested in doing these challenges, mark this step as complete and proceed to the next tutorial.

Switching back and forth between the UI Builder window and Game view can get a little tedious. Try creating a custom Editor Layout just for UI editing.

Open the UI Builder window and arrange it to take up one side of your screen in the Unity Editor.

Keep the Game view visible somewhere on the other side.

When you're happy with the layout, go to the upper-right corner of the Editor, open the Layout dropdown, and select Save Layout….

Expert: Add impact effects when obstacles collide

Make your game feel more reactive by spawning small bursts of particles every time obstacles bounce off walls. 

Create a small impact particle effect prefab (similar to your explosion but scaled down).

In your obstacle script, use OnCollisionEnter2D() to instantiate the small impact particle effect prefab at the collision point.

void OnCollisionEnter2D(Collision2D collision)
{
Vector2 contactPoint = collision.GetContact(0).point; 
  GameObject bounceEffect = Instantiate(bounceEffectPrefab, contactPoint, Quaternion.identity);

 // Destroy the effect after 1 second
   Destroy(bounceEffect, 1f);
}

Tip: You can even scale the effect based on rb.linearVelocity.magnitude to make bigger impacts for stronger impacts. To avoid spawning two particle effects for every collision, you could further optimize this by comparing the two colliding obstacles’ linear velocity and only spawning the particle effect for the faster-moving one. 

Combine your score system with PlayerPrefs to display the player’s best score ever.

Store the high score in PlayerPrefs (if it doesn’t already exist).

When the game ends, compare the current score with the saved one.

Add a new UI Label to display the high score along with the current score.

Note: You’ll likely need to do some online research and consult the Unity Manual for PlayerPrefs to achieve this.

Tip: Want to challenge yourself? Use UI Toolkit animation to make the high score fade in or flash if it gets beaten.

The UI Builder window showing (clockwise from left to right) the StyleSheets, Hierarchy, Library, Viewport, Inspector, and Project windows, and the Game view.

The Score label showing the current score of 21. Below this there is the High Score label, showing the high score of 376. The Score label has a white text on a black background, while the High Score label has white text on an orange background. 

In this tutorial, you added an explosion effect and a Restart button to complete your game loop. In the next tutorial, you’ll have the chance to add some more optional features to your game.

Restart the game with a bang

1. Overview

2. Add a basic particle system

3. Edit Emission, Shape, and Randomization

4. Make the explosion a prefab

5. Trigger the explosion from your script

6. Add and style the Restart button

7. Hide the Restart button at start

8. Show the Restart button on collision

9. Reload scene on click

10. Final script sample

11. Optional: More things to try

12. Next steps

Complete this tutorial