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 tutorial, you'll preview the finished version of Sprite Flight: a simple, 2D arcade game where you steer a triangular ship to dodge flying obstacles. Then, you'll create a new Unity project using Unity’s 2D template and set up the basic play area for your 2D game, complete with walls around the edges of the screen. 

Overview

Create a new 2D project

Set up your layout

Navigate around a new 2D scene

Add an Obstacle sprite

Change the size and background of the camera

Create the first screen border

Duplicate to make other screen borders

Lock the aspect ratio and adjust borders

Organize the Hierarchy window and Assets folder

Optional: More things to try

Next steps

Configure the scenes in the build

Switch to the Web platform

Build your project

Publish to Unity Play 

Test your game

Optional: More things to try 

Share your project [SUBMISSION STEP]

 Your next steps 

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

6ef1f031-d6af-552e-99e6-a620d8158f69:YHChT3yPJEkdVLlydIFMHY

Set up the Player GameObject

Add required physics components

Create the PlayerController script

Detect mouse clicks

Log the mouse position

Convert mouse position to world space

Rotate the Player GameObject to face the mouse

Apply thrust in mouse direction

Normalize the direction variable

Handle collisions

Clean up your code

 Final script sample

Identify the defaults elements in a new scene, Create and manipulate GameObjects and configure their components.

Scene Building Essentials

NealEdu

Product Manager at Unity

Control the execution of code with common logic structures 

Level 1 Application Scripting

Joy Horvath

Instructional Designer

GameObjects

lunaduranp

4.1 - Overview.mp4

4.2 - Set up the player GameObject.mp4

4.3 - Add required physics components.mp4

4.4 - Create the PlayerController script.mp4

4.5 - Detect mouse clicks.mp4

4.6 - Log the mouse position.mp4

4.7 - Convert mouse position to world space.mp4

4.8 - Rotate the player to face the mouse.mp4

4.9 - Apply thrust in mouse direction.mp4

4.10 - Normalize the direction variable.mp4

4.11 - Handle collisions.mp4

4.12 - Clean up your code.mp4

4.13 - Medium - Clamp the player’s max speed.mp4

4.13 - Expert - Add a visual booster flame.mp4

In this tutorial, you’ll create a controllable player ship that turns to face your cursor and moves in that direction when you click the left mouse button. Along the way, you’ll learn how to detect input, convert mouse cursor position into world space, apply directional thrust, and respond to collisions — all using Unity’s physics and input systems.

Gaming

Explain the Toolbar buttons used to manipulate objects.

Select a GameObject from both the Hierarchy window and the Scene view.

Link GameObjects in parent-child relationships using the Hierarchy window to create complex GameObjects.

Explain the relationship between the Scene view and the Inspector window.

Move, scale, and rotate a GameObject using the Toolbar buttons and the mouse in the Scene view.

Move, scale, and rotate a GameObject using the Transform Component in the Inspector window.

Position Sprites in 3D space in a 2D Scene.

Use 3D GameObjects in a 2D Scene to group Sprites.

3.1 Explain the Toolbar buttons used to manipulate objects.

3.2 Select a GameObject from both the Hierarchy window and the Scene view.

3.3 Link GameObjects in parent-child relationships using the Hierarchy window to create complex GameObjects.

3.4 Explain the relationship between the Scene view and the Inspector window.

3.5 Duplicate a GameObject.

3.6 Move, scale, and rotate a GameObject using the Toolbar buttons and the mouse in the Scene view.

3.7 Move, scale, and rotate a GameObject using the Transform Component in the Inspector window.

3.8 Position Sprites in 3D space in a 2D Scene.

3.9 Use 3D GameObjects in a 2D Scene to group Sprites.

Transform GameObjects

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

 Implement basic physics for GameObjects 

Apply RigidBody or RigidBody 2D components in order to enable GameObjects to act under the control of physics

Modify the basic properties of a RigidBody or RigidBody 2D component in order to control how the GameObject is affected by physics, including its mass, its drag, and the Scene's gravity

Add a collider to a GameObject and understand its function

Create and configure a Physic Material to add physical properties to a GameObject

Employ basic physics for GameObjects

Veronica Brown

Create a GameObject component with a script 

Before you can control the player, you need something to control. In this step, you’ll create a triangle-shaped Player GameObject, made up of multiple simple 2D shapes. This GameObject will represent the player’s ship and point in the direction it moves.

Right-click in the Hierarchy window and select Create Empty.

With the Player GameObject selected, in the Inspector set the Transform component’s Position property values to X = 0, Y = -4, and Z = 0.

Note: Positioning the Player GameObject at a negative Y value will move it down on the screen, giving the player a bit more room in front from their starting position.


2.  Add a triangle sprite as the main shape:

In the Hierarchy window, right-click the Player GameObject and select 2D Object > Sprites > Triangle.

Note: The problem with using a simple triangle like the default 2D sprite GameObject is that it would not be able to convey which direction the ship is facing. You need to add more shapes to make that more clear. 

In the Hierarchy window, right-click the Player GameObject again and add another 2D sprite (like a square, capsule, or another triangle).

Move, rotate, and scale the additional shape using the Rect tool (T).

Adding another shape helps visually indicate the ship's forward direction, which will become important when you apply thrust.


Use the Move tool (W), the Rotate tool (E) and the Scale tool (R) to adjust the shapes so the Player GameObject looks like a small ship, and the pointer clearly shows which way it's facing.

Tip: You can also scale the entire multi-part ship up or down by adjusting the Scale property values of the parent Player GameObject.

5. (Optional) Edit the Player’s sprite colors

Select all of the Player GameObject’s child GameObjects, select the Color swatch in their Sprite Renderer component, and change their color. 


You now have a visible player ship made from grouped sprites that’s ready for physics and input control in the next steps.

Now that your player ship is built, it needs physical properties so it can move and collide with other GameObjects. In this step, you’ll add a Rigidbody 2D component and collider components to allow the Player GameObject  to interact with the physics system.

Because your ship is made of multiple parts, you’ll use compound colliders — separate colliders attached to each child GameObject. Unity treats the combined colliders as one when physics is applied to the parent.

1.  Add a Rigidbody 2D component to the Player GameObject:

In the Inspector window, select Add Component and select Rigidbody 2D.

Set the Gravity Scale property to 0 — this ship will fly, not fall.



2.  Add colliders to all child GameObjects:

Hold Ctrl (macOS: Cmd) and select all the child GameObjects of the Player GameObject.

In the Inspector window, select Add Component > Polygon Collider 2D (or any other collider shape that fits).

Tip: The Polygon Collider 2D component is a flexible option that fits most sprite shapes closely.


The player won’t move yet, but it should now respond to physics — See what happens when one of the flying obstacles collides with the Player GameObject.

You’ve now given your player a physical presence in the world, using Rigidbody and compound collider components. Next, you’ll start scripting input so the ship can detect mouse clicks and respond.

In this step, you’ll create a new C# script called PlayerController and attach it to the Player GameObject. This script will handle all of the player’s input, movement, and collision logic.

This script is a custom component — a set of instructions you write that Unity will run during the game.

Right-click in the Scripts folder and select Create > MonoBehaviour Script.

Important: Make sure the filename is spelled correctly when you rename the script (PlayerController). Unity requires that the script name exactly matches the class name inside it. If the names don’t match, you’ll get an error. If you make a mistake on its spelling, delete the script and create it again with the correct name.

2.  Attach the script to the Player GameObject:

In the Hierarchy window, select the Player GameObject.

Drag the PlayerController script onto an empty space in the Inspector window or select Add Component and search for “PlayerController”.


You will now see the PlayerController script listed as a component on the Player GameObject.

You’ll edit this script over the next several steps to handle input and movement.

In this step, you’ll write your first input detection code — specifically when the mouse is clicked. To do that, you’ll use the Unity Input System, which requires adding a special using statement (like importing a library) at the top of your script.

You’ll also be working inside the Update() method for the first time. Update() is one of Unity’s lifecycle methods, and it runs once per frame — making it ideal for checking input, which can change at any time.

You’ll use the Console window to print a message every time the mouse is clicked so you can test that the mouse clicks are being detected correctly.

In the Scripts folder, double-click PlayerController.cs to open it in your code editor.


2.  Add code to detect clicks inside Update():

Inside your script, locate the Update() method.

Then, add the following lines of code inside the braces ({ }):



if (Mouse.current.leftButton.isPressed)
{
Debug.Log("Mouse was pressed");
}

This checks if the left mouse button is currently being pressed down.

Debug.Log() sends a message to Unity’s Console window, which you can use for testing.


3.  If you see an error under “Mouse”:

You might get a red underline or error in the Console window that says Mouse doesn’t exist — that’s expected!

To fix this error, add the following line of code at the very top of your script:

Tip: If you’re using a modern code editor like Visual Studio or VS Code, you might be able to hover over the error and select a Quick Fix to automatically add this line. If you don’t see an error under “Mouse”, it likely means your editor already added the correct using directive automatically for you as you were typing.

Press Ctrl+S (macOS: Cmd+S) to save your script.

Return to the Editor and enter Play mode.

While the game is playing, click in the Game view, then open the Console window by selecting the Debug message that appears underneath the Game view.  

Look for the message: "Mouse was pressed"



You’ve now detected real-time input using Unity’s Input System. Next we have to actually do something with that input. 

Now that your script can detect mouse clicks, it’s time to figure out where the mouse is clicking. In this step, you’ll log the mouse position when clicked. 

By default, Unity detects mouse position as a Vector3 (X, Y, and Z coordinate), but it does so in screen space — a coordinate system based on pixels where (0, 0) starts at the lower-left corner of the screen.

This is different from Unity’s world space, where (0, 0) is usually in the center of the scene. You’ll learn how to log the screen-space position now — and convert it to world space in the following step.

1.  Update your if block to store the mouse position:

Inside the if (Mouse.current.leftButton.isPressed) block, above your Debug.Log code, add the following line of code to declare a new mousePos variable:

Vector3 mousePos = Mouse.current.position.value;

A Vector3 is a structure that stores 3 values (X, Y, Z). Mouse position is given as a Vector3, even in 2D games.

This gives you the screen-space coordinates — based on the resolution of the Game view.


2.  Log the mouse position to the Console message:

Below the line you just added, edit the Debug.Log code to now display the mouse position, in addition to the fact that the mouse was pressed:

Debug.Log("Mouse position: " + mousePos);

Note: This is called string concatenation — combining a string ("Mouse position: ") with a variable (mousePos) to create a readable message in the Console.

Press Ctrl+S (macOS: Cmd+S) to save your script, then return to Unity and enter Play mode.

Click in the Game view and check the Console window. You’ll see coordinates like (245, 123,-10).


Notice how the numbers increase as you move the mouse to the right (X) and up (Y). This is different from Unity’s world space, which centers around (0, 0) — we’ll fix that in the next step.

You’ve logged the mouse position in screen space — but your Player GameObject moves in world space, so you need to convert those coordinates. In this step, you’ll use Unity’s Camera.main.ScreenToWorldPoint() function to translate the mouse’s position from screen space to a point in the game world.

This is one of the most important transformations in Unity when dealing with player input.

1.   Replace the old mouse position line with a world-space version:

Inside the if block, wrap your Mouse.current.position.value into the following new function:

Vector3 mousePos = Camera.main.ScreenToWorldPoint(Mouse.current.position.value);

Camera.main accesses your scene’s Main Camera GameObject.

ScreenToWorldPoint() takes screen coordinates (from the mouse) and converts them to world coordinates that match your scene layout.


Press Ctrl+S (macOS: Cmd+S) to save, then return to Unity and enter Play mode.

Click in the Game view and check the Console window. When you click the center of the screen, you’ll now see values centered closer to (0, 0) — which match your scene layout.

Note: The result is still a Vector3, and you might notice the Z position might be at an unexpected value — that’s okay in 2D! Since your game takes place in the X-Y plane, Z doesn’t affect gameplay here.

You’ve now successfully converted input from screen space to world space — which means your Player GameObject can begin responding to mouse position in a meaningful way.

Now that you know the position of the mouse in world space, you can rotate the player to face that position. You’ll do that by calculating the direction vector between the Player GameObject’s position and the mouse position, then setting the Player GameObject’s transform.up to that direction.

In Unity, transform.up controls which way a GameObject is facing in 2D — it’s the local Y-axis direction. When you set transform.up = direction, you’re telling Unity to rotate the GameObject so that its upward axis points toward that direction vector.

1.  Calculate the direction to the mouse:

Inside your if block (after getting the mouse position in world space), add the following line of code:


Vector2 direction = mousePos - transform.position;

This line subtracts two positions: the mouse's position minus the Player GameObject’s position.

The result is a 2D direction vector — a 2D line pointing from the Player GameObject to the mouse.


2.  Set the Player GameObject’s facing direction:

Add the following line of code underneath the previous one:

This tells Unity to rotate the player so that its “up” direction now points along the direction vector.

This is an easy way to rotate a GameObject without using angles or complex math.


Click in the Game view — the Player GameObject will now visually rotate to point toward the mouse.


Steer the player

1. Overview

2. Set up the Player GameObject

3. Add required physics components

4. Create the PlayerController script

5. Detect mouse clicks

6. Log the mouse position

7. Convert mouse position to world space

8. Rotate the Player GameObject to face the mouse

9. Apply thrust in mouse direction

10. Normalize the direction variable

11. Handle collisions

12. Clean up your code

13. Final script sample

14. Optional: More things to try

15. Next steps

Complete this tutorial