All content in this course uses:

Add a survival-time scoring system and display the score onscreen using Unity’s UI Toolkit.

Add a scoring system

In many games, scoring helps provide feedback and motivation to players. In this tutorial, you'll add a basic scoring system to your game that tracks how long the player survives and displays their score on the screen using Unity's 

Overview

To begin calculating a score, you first need to measure how long the player has been alive. Unity provides a helpful built-in value called 

, which returns the time in seconds since the last frame. By adding this value to a running total each frame, we can track how long the player has survived — regardless of frame rate. In this step, you’ll implement this timer inside your 

1.  Declare a variable to store elapsed time:

Near the top of the class (after your other variable declarations), add the following line of code:

 is not required — Unity automatically treats variables as private if you don’t specify them as private or public. Still, it’s a good habit to include 

 explicitly. This makes your code easier to understand by clearly showing which variables are private and which are public.

2.  Increment elapsed time using Time.deltaTime:

 method, add the following line of code at the top:

  is a shorthand for "add to this variable."

 is the time (in seconds) since the last frame.

If you add that small number every frame, it adds up over time. The result is a running total of how much time has passed since the game started — this works no matter what the frame rate is.

3.  Log the result in the Console window:

Below the line you just added, add the following line of code:

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

window to see the timer increase over time.

 GameObject collide with an obstacle and notice that the log stops. This script is attached to the 

GameObject, so when it gets destroyed — the timer stops because the script is no longer in the scene.

Your game now tracks how long the player survives using 

 Track elapsed time

Now that you’re tracking how long the player has survived, it’s time to turn that into a score. It wouldn’t be very interesting if the score just went up by 1.0 every second. 

In this step, you’ll create two new variables: one to hold the final score and one to define a score multiplier. Then, you’ll display that score using 

1.  Declare the score and multiplier variables:

 script, add the following lines of code near your other variables:

You might want the score multiplier to be public if you want to adjust it in the 

 line will display the score instead of the elapsed time.

window to see the score increase over time.

, your result will include decimal points (for example, 

). Don’t worry — you’ll round that value to an integer in the next step.

Add a score multiplier

Right now, the score displays as a long decimal number, which can be hard to read and doesn’t feel very game-like. Most games use whole numbers for score displays. In this step, you’ll use 

, a Unity function that rounds a decimal number down to the nearest whole number. You’ll also learn what an 

 is and why you’d use it instead of a float when displaying clean numbers.

1.  Round the score using Mathf.FloorToInt():

Replace the line where you calculate the score with the following line of code:

 is a whole number (like 0, 1, 25). It doesn’t store decimal places.

 takes a decimal (float) and returns the largest whole number less than or equal to that value.

This ensures the score only increases after full seconds have passed — which is useful if, for example, you want the player to earn 1 point per second of survival.

, giving credit before the full second has actually passed.

window should display clean whole numbers like 

Round the score to an int

Now that the score is being calculated correctly, it’s time to display it on the screen. In Unity, you can create user interfaces using the 

 (a markup language similar to HTML). This step walks you through creating a UI Document and connecting it to your scene so you can begin building a heads-up display (HUD) for your score.

1.  Create a UI Document GameObject in the scene:

3.  Link the asset to the scene's UI Document:

GameObject in the scene is what actually displays the interface during gameplay.

 asset you just created) defines the structure and layout of the UI.


You won’t actually see any UI elements on the screen yet; you’ve just created the UI container that will hold your score display.

 Set up a UI document

With the UI container set up in your scene, the next step is to design the actual interface that’ll display your score. You’ll do this using the 

 window, a drag-and-drop editor for creating UI layouts visually. In this step, you’ll add a 

, give it a clear name, and set some placeholder text.

1.  Open the UILayout asset in UI Builder:

You’ll now see a text label appear in the 

element by setting its name at the very top of the 

Spelling is important here — you’ll use this name in your script to reference the label later.

 box, change the placeholder text to “Score: 0”.

Back in the Unity Editor, you will see the “Score: 0” text appear in the upper left corner of the screen, though it may be hard to see against a dark background — you’ll fix that next.

Add the score label

By default, UI elements added in UI Builder are small, plain, and usually tucked in the upper-left corner. In this step, you’ll center the label horizontally and give it some visual breathing room using 

 — direct style settings applied to individual UI elements.

1.  Reopen the UILayout in UI Builder (if closed):

 window looks zoomed or misaligned, select 

 at the top of the window to recenter it.

2.  Select the ScoreLabel in the UI Hierarchy panel:

 (pixels). This will move the score down a bit so it’s not overlapping the top border wall.

 that contrasts well with your background.

 asset and return to the Unity Editor to preview your score UI formatting.


 should be clearly visible, centered near the top of the screen, and easy to read.

Style the label

Before your script can update the score label, it needs to access the UI that’s visible in the scene. To do that, you’ll get a reference to the 

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

window, where you can assign it manually without writing extra code. This is a common and beginner-friendly way to connect scene references.

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

 This line gives your script access to Unity’s 

 classes. If you're using autocomplete in your IDE, it may have already added this line for you automatically.

3.  Assign the UI Document in the Inspector window:

Save your script and return to the Unity Editor. 

After this step, your script has access to the UI and is ready to find and modify specific elements inside it.

Get a reference to the UI document

Now that your script can access the UI document in the scene, the next step is to find the score label inside it and update its text. 

1.  Add a variable to reference the label:

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

 is the specific UI Toolkit class used for displaying text. This line prepares a variable to hold the reference to the 

 method, add the following line of code to initialize the variable:

 gives you access to the top-level container of the UI layout.

Make sure the name exactly matches what you set in 

Notice that you’re now setting the text with the same message that you had previously logged to the 

 If the label doesn’t update during Play mode, double-check the following possible causes:

 window exactly matches what you entered in the script.

After this step, your score will be displayed live on screen and will update smoothly during gameplay.

Set the score text with true score

The score label looks fine on your current screen, but if you resize the 

 view or change aspect ratios, it might shift or appear too small. With these settings in place, if someone plays your game on a huge high resolution monitor or on a small low resolution phone, the UI could change in unexpected ways.  To address this, you’ll adjust the 

 so your UI scales automatically with the screen. This is an easy way to ensure your UI remains readable and correctly positioned on any resolution or device.

1.  Experiment with different Game view resolutions: 

 dropdown to select a few different screen resolutions. 

Notice that the score text gets smaller and changes position at higher resolutions. 


 asset that was automatically created when you added the UI Document to the scene. It’s usually inside a folder called 

3.  Set it to scale with the screen size:

4.  Adjust the reference resolution if needed:

If the UI elements became smaller or larger than you’d like, under the 

After changing this setting, test different 

 view aspect ratios from the dropdown in the 

 view or by dragging the top edge of the 

 view up and down. The score label should now stay anchored and readable regardless of window size.

Scale with screen size

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. 

Final script sample

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

 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. 

Copy and paste the score-related code into 

Copy and paste the if-statement that moves the player into 

Breaking up your code into smaller, named methods makes it easier to understand and maintain.

UI Toolkit allows you many more options for styling UI elements. With these tools, you can make your score stand out even more. 

 property: you can add an outline and round out the corners. 

 to something semitransparent so you can still see the obstacles behind it. 

Custom fonts can give your game a unique look. Try importing a new font for use in your score label.

Imported fonts will automatically become available for use in the 

Optional: More things to try

In this tutorial, you created a scoring system that tracks how long the player survives and displays the score on screen using UI Toolkit. In the next tutorial, you’ll build a game over effect with a particle explosion and a 

 button to reset the game when the player is destroyed.

Next steps

Control the execution of code with common logic structures 

Level 1 Application Scripting

Joy Horvath

Instructional Designer

Create simple functional user interfaces, including images, text, buttons, toggles, and sliders.  

Beginner User Interface

ElizabethMidgley

GameObjects

lunaduranp

Gaming

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

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

Control how the entire UI responds to changes in screen resolution by understanding different Canvas Scaler modes, such as "Constant Pixel Size" and "Scale with Screen Size"

Control how UI elements scale, rotate, and reposition relative to other objects on screen by editing anchor and pivot points.

Identify the use cases for different Canvas render modes: Screen Space - Overlay, Screen Space - Camera; World Space.

Effectively use anchos by understanding the importance of parent and child relationships for UI elements

Change the aspect ratio of the Game View window in order to preview how your UI will appear on different screens

Understand the role of the Canvas GameObject in designing a UI

Position 2D elements on screen by using the Rect Transform component and Rect tool

Anchor a UI element to different parts of a Canvas by using presets and by positioning it manually

Customize Text element styling in the Inspector

Apply and configure materials to an Image component

Unity Version 6.3