Introduction to real-time 3D experience design

Set up version control

Explore the sample project

Principles of object-oriented programming

Create a scene flow

Implement data persistence between scenes

Implement data persistence between sessions

Quiz: Manage scene flow and data

Submission: Data persistence in a new repo

Learn about data persistence and an introduction to the core pillars of object-oriented programming.

In this mission, you’ll learn about data persistence, or how to manage the loading and unloading of data between both scenes and sessions. Along the way, you will be introduced to the core pillars of object-oriented programming, which will help you structure your code throughout the mission. There will only be one practical example throughout the mission, which will build on the new functionality you create with each tutorial. At the end of this mission, you’ll take everything you learned and apply it to a new project by building a persistent score system for a small game.

Manage Scene Flow and Data

Unity Junior Programmer

Kickstart your programming career with Unity's Junior Programmer Pathway. Learn coding fundamentals, C#, and game development to create your first interactive projects. Start learning for free!

Junior Programmer Pathway - Learn Coding & Game Development | Unity Learn

We recommend that you have basic knowledge of Unity or complete 

Ready to code? This guided learning Pathway will take you from zero to job-ready!

Welcome to Junior Programmer! Designed for anyone interested in learning to code or obtaining an entry-level Unity role, this pathway assumes a basic knowledge of Unity and has no math prerequisites. Junior Programmer prepares you to get Unity Certified so that you can demonstrate your job-readiness to employers.

Junior Programmer

Course Introduction

Install Unity Software

Unit 1 - Introduction

Lesson 1.1 - Start your 3D Engines 

Lesson 1.2 - Pedal to the Metal

Lesson 1.3 - High Speed Chase

Lesson 1.4 - Step into the Driver's Seat

Challenge 1 - Plane Programming

Lab 1 - Project Design Document

Introduction to project management and teamwork

Quiz 1

Learn how to create new C# scripts, call basic functions, and use variables to modify the results of those functions.

In this first mission in the Junior Programmer pathway, you will program a car moving side-to-side on a floating road, trying to avoid (or hit) obstacles in the way. In addition to becoming familiar with the Unity editor and workflow, you will learn how to create new C# scripts and do some simple programming. By the end of the Unit, you will be able to call basic functions, then declare and tweak new variables to modify the results of those functions.

Player Control

Unit 2 - Introduction

Lesson 2.1 - Player Positioning

Lesson 2.2 - Food Flight

Lesson 2.3 - Random Animal Stampede

Lesson 2.4 - Collision Decisions

Challenge 2 - Play Fetch

Lab 2 - New Project with Primitives

Quiz 2

Mod the Cube

Quiz: Create with Code 1

Gain familiarity with some of the most important programming and Unity concepts, including if-then statements, random value generation, arrays, collision detection, prefabs, and instantiation.

In this Mission, you will program a top-down game with the objective of throwing food to hungry animals - who are stampeding towards you - before they can run past you. In order to do this, you will become much more familiar with some of the most important programming and Unity concepts, including if-then statements, random value generation, arrays, collision detection, prefabs, and instantiation. In completing this Unit, you will learn how to program a basic game with the ability to launch projectiles and maneuver the player to keep the game alive.

Basic Gameplay

Unit 3 - Introduction

Lesson 3.1 - Jump Force

Lesson 3.2 - Make the World Whiz By

Lesson 3.3 - Don't Just Stand There

Lesson 3.4 - Particles and Sound Effects

Challenge 3 - Balloons, Bombs, & Booleans

Lab 3 - Player Control

Quiz 3

Learn how to add music, sound effects, and visual particle effects to transform the experience of your project.

In this Mission, you will program a fast-paced endless side-scrolling runner game where the player needs to time jumps over oncoming obstacles to avoid crashing. In creating this prototype, you will learn how to add music and sound effects, completely transforming the experience of your projects. You will also learn how to create dynamic endless repeating backgrounds, which are critical for any side-scrolling games. Finally, you will learn to incorporate particle effects like splatters and explosions, which make your games so much more satisfying to play.

Sound and Effects

Unit 4 - Introduction

Lesson 4.1 - Watch Where You’re Going

Lesson 4.2 - Follow the Player

Lesson 4.3 - PowerUp and CountDown

Lesson 4.4 - For-Loops For Waves

Challenge 4 - Soccer Scripting

Lab 4 - Basic Gameplay

Quiz 4

Learn how to implement new gameplay mechanics including powerups and increasing difficulty.

In this Mission, you will program an arcade-style Sumo battle with the objective of knocking increasingly difficult waves of enemies off of a floating island, using power ups to help defeat them. In creating this prototype, you will learn how to implement new gameplay mechanics into your projects, which are new rules or systems that make the game more interesting to play. On one hand, you will learn to program a powerup, which give the player a temporary advantage. On the other hand, you will learn to program increasingly difficult enemy waves, which make survival more challenging for the player. A good balance of powerups and increasing difficulty make for a much more interesting gameplay experience.

Gameplay Mechanics

Unit 5 - Introduction

Lesson 5.1 - Clicky Mouse

Lesson 5.2 - Keeping Score

Lesson 5.3 - Game Over

Lesson 5.4 - What’s the Difficulty?

Challenge 5 - Whack-a-Food

Lab 5 - Swap out your Assets

Quiz 5

Introduction to user feedback and testing

Learn how to implement a User Interface - or UI - into your projects, such as a title screen and score display.

In this Mission, you will program a game to test the player’s reflexes, where the goal is to click and destroy objects randomly tossed in the air before they can fall off the screen. In creating this prototype, you will learn how to implement a User Interface - or UI - into your projects. You will add a title screen with a difficulty select menu that will control how challenging the gameplay is, you will add a score display that will track how many points the player has earned, and you will add a Game Over screen, which will allow the player to restart and try again. In learning these skills, you will be able to create a fully “playable” experience that the user can enjoy from start to finish without having to restart the application to try it again.

User Interface

Next Steps - Introduction

Lesson 6.1 - Project Optimization

Lesson 6.2 - Research and Troubleshooting

Lesson 6.3 - Sharing your Projects

ECS Survival Guide

Career research and preparation

Introduction to portfolios

Debug the App

Counting Prototype

Quiz: Create with Code 2

Prepare to continue developing your Unity and C# skills independently, including learning how to complete your personal project.

In this Mission, you'll prepare to continue developing your Unity and C# skills independently, including learning how to complete your personal project and how to prepare for the Unity Certified User: Programming exam, which you can take through your school program, if available.

Publishing Your Project

Abstraction in object-oriented programming

Inheritance and polymorphism in object-oriented programming

Encapsulation in object-oriented programming

Profile code to identify issues

Job preparation: Junior Programmer

Quiz: Apply object-oriented principles

Submission: Programming theory in action

Deep-dive into the pillars of object-oriented programming and their application, then learn how to profile and optimize code.

In this mission, you’ll refactor the inventory project you completed in the previous mission using the pillars of object-oriented programming as a guide. You’ll deep dive into the inner workings of each pillar individually, so you can better understand its value in developing applications. Next, you’ll learn how to profile your code to identify any optimization bottlenecks that would slow down the final build of your application. To close out this mission, you’ll develop a small application for your portfolio that uses fully optimized code built on OOP principles. 

When you complete this mission you will complete the Junior Programmer pathway - CONGRATULATIONS!

Apply Object-Oriented Principles

cd416b50-a7d8-4238-a332-cc820d2db1c2:e1d9a3ded659

Overview

Evaluate your brief

How can data persist between sessions?

What is JSON?

Why is JSON a good fit for your brief?

Add a SaveData class

Add a SaveColor method

Add a LoadColor method

Load and save the color in the application

Add testing functionality

Next steps

Warehouse-data-between-sessions.mp4

In this tutorial, you’ll write code to save and load the color that the user selects so that it persists between sessions of the application. By the end of this tutorial, you will be able to:

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

Store and organize data by applying data structures such as lists and dictionaries

Save user data in the shutdown sequence of the app

Junior Programmer: Manage scene flow and data

Unity for Artists Curricular Framework Resources

AI, ML Curricular Framework Resources 

Right now, when you’re testing the work-in-progress application in Unity Editor, the color that you select for the forklifts in the warehouse won’t be saved the next time you test the application. If you create a build of this app, it will be a standalone experience each time the user runs it.

It would be helpful to save the user’s last chosen color, so that it’s automatically selected when they start the application. In this tutorial, you’ll build on your previous work to implement data persistence between scenes and do so between sessions.

Here’s what that might look like in your project:

Tip: If you’ve taken a break between this tutorial and the previous one, you might find it helpful to review the introduction to data persistence before continuing. 

In this tutorial, you’re going to write the color selected by the user to a file. Then, you’re going to configure the MainManager to check whether that file exists when the application starts. If the file does exist, then the MainManager will read the color stored to it and set the color picker to that color.

Before you get started, take a few minutes to review the project brief. Imagine that you will perform this task on your own. Write down answers to the following questions:


What do you need to implement, and where will you implement it ? Write down your thoughts now, to compare them with the approach we take.



Where have you encountered similar functionality before, in Create with Code or other learning experiences? Even if you can’t access the code, think about examples of data persistence between sessions that you’re familiar with.



Beyond Unity Learn, what resources could help you do this? Think about options within the Unity ecosystem and beyond it.

Taking a few minutes to reflect on what you already know before you begin a task is a very useful exercise, particularly if that task feels challenging. If you completed Unity Essentials, you explored the mindset established creators take to learn Unity. This is a great time to refresh your memory of that approach.  

Identifying the tools at your disposal and reviewing your previous learning can provide really helpful opportunities to think through different approaches to meet a brief. You can take this approach as you continue your learning journey far beyond this pathway — it’s rare that there’s only one way to do something!

For data to persist between sessions, it needs to be stored in some way. In your case, you’ll need to convert the color your user selects into a format that can be stored and then read when they load the application again.

The process of converting complex data into a format in which it can be stored is called serialization. When you’re ready to access the data again, the process of converting it back is called deserialization. 

There are different formats that you can use to store data, depending on what the data is and what you want to do with it. In this case, you’re going to use the JSON format. 

Flow diagram shows the process of serialization: an object being converted to bytes and then stored; the deserialization process shows this in reverse.

JSON is a text format used to store data and exchange it between platforms. It was first developed for the web, and its full name is  JavaScript Object Notation. It’s based on JavaScript but is language independent — you can use it whether you’re writing C# code or using any other programming language.


The JSON format stores data in the form of a key:value pair. The key is a string, and the value can be:

The following JSON string encodes an object storing basic information about a person:

{
  "name": "John",
  "age": 27,
  "address": {
    "streetAddress": "21 2nd Street",
    "city": "New York"
  }
  "pet": [“dog”, “cat”]
}


Each object is surrounded by curly braces ( { } ).

Each entry is in the form of a key:value pair, separated by a comma.

The entry “pet” is an array of strings — array values are listed between square brackets ( [ ] ).

The value associated with the entry “address” is between curly braces too — this is because it is another JSON object. 

JSON was developed to exchange data between very different systems, which makes it a good fit for saving data in your application. Unity has a helper class called JsonUtility, which allows you to take a serializable class and transform it into its JSON representation. Let’s see how this works for both serializing and deserializing data.

[Serializable]
public class PlayerData
{
    public int level;
    public Vector3 position;
    public string playerName;
}

Imagine that you want to pass this class to JsonUtility with the following values:

PlayerData myData = new PlayerData();
myData.level = 1;
myData.position = new Vector3(3.0f, 4.4f, 2.3f);
myData.playerName = "John";

Calling string json = JsonUtility.ToJson(myData); will result in the following JSON string: 

{
    “level”: 1,
    “position”: {
        “x” : 3.0,
        “y” : 4.4,
        “z” : 2.3 },
    “playerName”: “John”
}


Note that since position is a vector3, it is encoded as a new JSON object with three keys: x, y, and z. This is because the Vector3 class (extremely simplified) is: 

[Serializable]
public class Vector3
{
    public float x;
    public float y;
    public float z;
}

JsonUtility also has a method that does the inverse of the process you’ve just seen: FromJson<T>.

This method will take a string containing some JSON data and create an instance of the object with its fields filled in. It uses a template argument — as you may have noticed when reviewing the PlayerData JSON string, the original type of that data is not stored in the JSON file. Unity needs the template argument to read the right value in the right field.

To extend our example, calling PlayerData myData = JsonUtility.FromJson<PlayerData>(json); will fill myData with the values in the JSON string.

There are some limitations to Unity’s JsonUtility class, which was designed for performance and simplicity. JsonUtility doesn’t work on primitive types, arrays, lists, or dictionaries. 

As you might expect, JsonUtility only works on the Serializable type — MonoBehaviour or the other classes/structs you write onto which you can add the [Serializable] attribute. If you try to save a class that contains multiple pieces of data and one of them won’t save, it’s probably because it isn’t serializable. For example, if you convert a class to JSON that has a dictionary in the middle, the dictionary won’t be saved because it’s not serializable. If something appears not to be saving properly in a class, check to make sure that it’s a serializable type!

For more information, consult the Unity documentation on JSON Serialization. 

To save and load the user’s last chosen color, you’ll need three things in the MainManager class:

A Save method that transforms that class into JSON format and writes it to a file.

A Load method that transforms the data from the JSON file back into the SaveData class.

2.  Add the following code at the end of the MainManager class (within the scope of its closing brace):

[System.Serializable]
class SaveData
{
    public Color TeamColor;
}

3.   The final line will be highlighted as an error in your IDE because we need to add a new namespace to the script. At the top of your script, add the following:

SaveData is a simple class, which only contains the color that the user selects. Note that you have added a [System.Serializable] attribute above it. This line is required for JsonUtility, as you just learned — it will only transform things to JSON if they are tagged as Serializable.

Why are you creating a class and not giving the MainManager instance directly to the JsonUtility? Well, most of the time you won’t save everything inside your classes. It’s good practice and more efficient to use a small class that only contains the specific data that you want to save.

1.  Leave a line free after the SaveData class.

public void SaveColor()
{
    SaveData data = new SaveData();
    data.TeamColor = TeamColor;

    string json = JsonUtility.ToJson(data);
  
    File.WriteAllText(Application.persistentDataPath + "/savefile.json", json);
}

Let’s break down this new method in sequence. First, you created a new instance of the save data and filled its team color class member with the TeamColor variable saved in the MainManager:

SaveData data = new SaveData();
data.TeamColor = TeamColor;

Next, you transformed that instance to JSON with JsonUtility.ToJson: 

Finally, you used the special method File.WriteAllText to write a string to a file: 

File.WriteAllText(Application.persistentDataPath + "/savefile.json", json);

The first parameter is the path to the file. You’ve used a Unity method called Application.persistentDataPath that will give you a folder where you can save data that will survive between application reinstall or update and append to it the filename savefile.json.

Note: The Unity Scripting API lists the actual paths per platform.

The second parameter is the text you want to write in that file — in this case, your JSON!

1.  Leave a line free after the SaveColor method.

public void LoadColor()
{
    string path = Application.persistentDataPath + "/savefile.json";
    if (File.Exists(path))
    {
        string json = File.ReadAllText(path);
        SaveData data = JsonUtility.FromJson<SaveData>(json);

        TeamColor = data.TeamColor;
    }
}


This method is a reversal of the SaveColor method: 

string path = Application.persistentDataPath + "/savefile.json";

It uses the method File.Exists to check if a .json file exists. If it doesn’t, then nothing has been saved, so no further action is needed. If the file does exist, then the method will read its content with File.ReadAllText: 

if (File.Exists(path))
{
    string json = File.ReadAllText(path);

It will then give the resulting text to JsonUtility.FromJson to transform it back into a SaveData instance: 

SaveData data = JsonUtility.FromJson<SaveData>(json);

Finally, it will set the TeamColor to the color saved in that SaveData: 

Before you continue, double check the code you’ve added to make sure it’s within the scope of the MainManager class:

[System.Serializable]
class SaveData
{
    public Color TeamColor;
}

public void SaveColor()
{
    SaveData data = new SaveData();
    data.TeamColor = TeamColor;

    string json = JsonUtility.ToJson(data);
  
    File.WriteAllText(Application.persistentDataPath + "/savefile.json", json);
}

public void LoadColor()
{
    string path = Application.persistentDataPath + "/savefile.json";
    if (File.Exists(path))
    {
        string json = File.ReadAllText(path);
        SaveData data = JsonUtility.FromJson<SaveData>(json);

        TeamColor = data.TeamColor;
    }
}

You’re nearly finished, but first you need to load the saved color (if one exists) when the application starts and save the color on exit. Let’s implement that now:

1.  In MainManager.cs (which you should still have open), find the Awake method. 

2.  Call the LoadColor method at the end of Awake:

3.  Save your changes, then open MenuUIHandler.cs in your IDE.

4.   At the end of the Start method, add the following code:  

ColorPicker.SelectColor(MainManager.Instance.TeamColor);

This line will pre-select the saved color in the MainManager (if there is one) when the menu screen is launched.

5.  At the beginning of the Exit method, add the following code: 

This line will save the user’s last selected color when the application exits. 

Finally, let’s add some quick testing functionality to the MenuUIHandler so that you can save and load the color from the application instantly:

1.  Add the following two methods to MenuUIHandler.cs: 

public void SaveColorClicked()
{
    MainManager.Instance.SaveColor();
}

public void LoadColorClicked()
{
    MainManager.Instance.LoadColor();
    ColorPicker.SelectColor(MainManager.Instance.TeamColor);
}

Implement data persistence between sessions

1. Overview

2. Evaluate your brief

3. How can data persist between sessions?

4. What is JSON?

5. Why is JSON a good fit for your brief?

6. Add a SaveData class

7. Add a SaveColor method

8. Add a LoadColor method

9. Load and save the color in the application

10. Add testing functionality

11. Next steps

Complete this tutorial