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

092d2b47-21b2-4d7b-97ba-4559d8da6ea5:bf937d656db0

Overview

What is version control?

Who uses version control?

Select your version control tool

Get started with GitHub Desktop

Create a new repo on your hard drive

Download, open, and start tracking your project

Do an initial commit and publish your repo

How does version control work?

Summary

In this tutorial, you’ll learn about the basics of Version Control, and the reasons to implement it in your own projects, even if you’re developing applications by yourself. You’ll also learn about the different Version Control options available to use with Unity, and put your new skills into practice by downloading the project that you’ll use throughout the upcoming tutorials.

By the end of this tutorial, you will be able to:

Identify the different version control solutions that can be used to maintain a project.

Describe how version control is used to maintain a project

Designed for post-secondary and K-12 educators at accredited academic institutions teaching Unity in the classroom, the Unity Educator plan provides you with free access to the same real-time 3D development tools used by professionals to support your students.

Included in this plan are Unity Pro, cloud-based collaboration, cloud build, free Unity assets, and much more!

Junior Programmer Pathway Facilitator Kit.zip

Junior Programmer Pathway Facilitator Kit (Google Drive)

Unity Educator Hub

The Unity Junior Programmer Pathway Facilitator Kit includes everything you need to successfully bring this Pathway into your learning context including a syllabus, complete lesson plans, standards alignment, teacher preparation guide, and more. 

Junior-Programmer-Starter-Files_U6.zip

Junior Programmer: Manage scene flow and data

Unity for Artists Curricular Framework Resources

AI, ML Curricular Framework Resources 

Whether you’re working alone or on a team, an important aspect of project development is deciding how you’ll manage your project files. If you’re a solo developer, there’s always some level of risk associated with keeping the only instance of your project on a local hard drive — if the drive fails, your project is lost! Keeping multiple backup copies of your project on different drives or stored in the cloud can be cumbersome to keep up to date. If you’re a developer on a team, you have to determine how everyone will access the project, and how to ensure that the work one person is doing doesn’t overwrite or damage the work of someone else. 

Fortunately, the solution to all of these issues is quite simple: version control.

If the idea of working with version control seems intimidating, don’t worry! Many people feel overwhelmed by the idea of version control when they are first getting started with development. False starts and confusion when attempting to set up that first repository can make new developers hesitant to try again, despite how helpful version control can be. If you fall into this category, take heart that you aren’t alone — and try again in this project!

Version control (which is sometimes called source control) is a system that manages and tracks information. Version control systems can be configured to store, manage, and track changes to any kinds of files, software, websites, or other data. 

Individuals, small teams, or large organizations will often use a version control system to help back up and manage complex projects. Since version control systems work with cloud storage services, you can take advantage of useful features such as:


In this tutorial, you’ll learn about version control systems which use cloud storage, as opposed to those that use localized storage, which is more suitable for special team circumstances.

When multiple team members are involved with developing coordinated projects or software, it can become difficult to manage without a version control system in place. Everyone needs it!

As a project becomes more complex, team members need to stay up to date with changes their fellow teammates make. If they don’t coordinate consistently, they will face inefficiencies, bottlenecks, lost code, rework, and a lot of frustration. The purpose of version control is to avoid these issues. 

Version control systems vary depending on your project needs. Unity has its own version control solution called Unity Version Control, which is available as a package. However, for this learning project, we’ll be using Github, an extremely popular version control solution that you’re likely to encounter during your development career. It’s also easy to work with, especially for beginners with version control. 

To make things even simpler,  we’ll guide you to use GitHub Desktop, an easy-to-use application that allows you to access GitHub projects through a graphical user interface, instead of from a command line using Git commands. If you are already familiar with GitHub or prefer to work with the command line, feel free to skip the next step!

If you’re interested in reading more about how Unity integrates with other version control systems, please refer to Get started with Unity Version Control and Working with Unity and Helix Core Perforce.

To create a GitHub repository, , you’ll need to sign up for a free GitHub account and install GitHub Desktop. 

1.  If you don’t already have one, sign up for a free GitHub account at github.com.


2.  Download and Install GitHub Desktop at desktop.github.com, which is available for both Mac and PC. The site should automatically detect what platform you’re using, or you can manually select your platform type.

3.  After installation, sign into your account on GitHub Desktop: 

On Windows, select File > Options > Account. 

On Mac, select GitHub Desktop > Preferences.

More information about logging in and authenticating your account can be found in the GitHub documentation.

If you don’t already have any repositories associated with your account, you should now see this welcome screen, encouraging you to get started!
 

GitHub Desktop welcome screen, with “Let’s get started!” at the top.

A GitHub repository (usually shortened to “repo”) is a folder that a project lives in. Inside this folder, any and all changes are carefully tracked by your version control software. The first thing to do is create an empty repo that is configured specifically for a Unity project.

1.  From the welcome screen in GitHub Desktop, select Create a New Repository on your Hard Drive.
 

You can also click File > New Repository from the top menu of GitHub desktop.

2.  In the Create a New Repository window that appears, configure your repo’s settings:

Give your repo a Name like “Jr-Programmer-Project”. Note that spaces will be replaced with hyphens.

Select the Local Path where you would like to save your repo. A folder with the name you just entered will be created there.

From the Git Ignore dropdown, select the Unity option. This will create a preconfigured .gitignore file in your repo that lists all the file types that you do not want to store in version control. For Unity, that means it will only focus on the files specific to your project, and ignore everything else. 

3.  Select Create Repository. This will set the Current Repository dropdown to your new repo. In the main window, you will see that there are currently “No local changes.” That is because this is a brand new repo that you haven’t edited yet.  

4.  Open the folder that was just created on your computer at the location you specified. If your computer is configured to view hidden files, you will see it contains three items: 

The .git folder tells GitHub that this is, in fact, a GitHub repo. The .gitignore and .gitattributes specify the configuration of your repo. It’s not necessary, but if you would like to see these hidden files, you can Google how to do so for Windows or Mac.

To give GitHub something to track, you will put an actual Unity project in this folder in the next step.

On the GitHub Desktop welcome screen, the Create a New Repository on your Hard Drive button is highlighted.

Create a New Repository Window in GitHub Desktop with the Name, Local Path, and Git Ignore fields highlighted.

GitHub Desktop repository window with Current Repository set to Jr-Programmer-Project.

File Explorer showing the contents of the Jr-Programmer-Project repo folder.

With your empty repo patiently awaiting changes to track, let’s add a Unity project to it and open it for the first time.

1.  Download the project zip folder, extract it, and open the Junior-Programmer-Starter-Files folder. In it, you find the following folders:

2.  Use Ctrl+A (Windows) or Cmd+A (Mac) to select all three folders, then copy and paste them into your repo folder, right next to your hidden .git files. This folder is now ready to be opened as a Unity project. 


3.  Add your project repo folder to Unity Hub, and then open the project in the Unity Editor. 

Note that this project requires Unity 6 LTS or higher. If it’s not installed, a warning notification will be displayed below its listing in the Unity Hub with a prompt to install the correct version.  

4.  In your Github Desktop window, a long list of new files now appears in the Changes panel with a little green plus (+) icon next to each file, indicating that it’s new.  

Congratulations! Your project is now ready for version control. Any changes you make to this project will be tracked by GitHub.  

Unity Editor showing contents of the Project in the Project window and an empty scene in the Scene view. 

Changes panel in GitHub desktop showing a list of 164 changed files, all of which have blue checkmarks next to their names, indicating they are selected.

The first set of files you commit to your repo will be included in the initial commit. You would usually do an initial commit after you first set up your project, so let’s do that now.

1.  In the Summary field below the changes listed to your repo, type “initial commit” and fill in the Description (e.g. “project starter files”). Then select Commit to main to save your changes to the “main” branch of the project. If you don’t know what branches are, don’t worry — we’ll cover that in a later tutorial.

After you click Commit, all of the changes listed should disappear, since they are now safely stowed away in version control. 

However, even though all of your changes will be tracked locally on your hard drive, what if you accidentally drop your computer off a cliff? All your work would be lost! Let’s back up your project on the cloud just in case.

2.  From the GitHub Desktop interface, select Publish Repository. 

3.  In the window that opens, confirm the Name of your project, and whether you want to keep your code public or private. Then select Publish Repository. 

4.  To see your repo backed up and published on GitHub.com, go to the top menu of GitHub desktop and select Repository > View on GitHub. Here, you can explore all of the files, view the commit history, log issues, and a lot more. Feel free to explore the interface to get a bit more comfortable. 

Commit panel of Github Desktop with the Summary set to “initial commit” and the Description set to “project starter files”

GitHub Desktop window with Publish Repository button highlighted.

Publish Repository window of GitHub Desktop interface with Name set to “Jr-Programmer-Project” and “Keep this code private” selected.

When you use version control, you’ll save your changes to the project via a cloud repository (or file storage directory) with a note documenting the changes that you’ve made. 

This means that you’ll be able to pull (download) and open up the most recent version of a project, make changes to it locally, and then push (upload) your changes back to the cloud repository. 

When multiple people are working on the same project simultaneously, they can sometimes make different changes to the same file. For example, one person might change the texture assigned to a prop asset in a Unity project and another might change its position in the scene. Version control manages the project files to combine and unify all the changes in a process known as a merge. Occasionally, the changes made to a project file may affect the same values. When this happens, the version control system is unable to merge the changes together, resulting in a merge conflict, which requires a developer’s input. The version control system will identify the conflict, typically displaying the two different values side by side. The developer then determines which one to keep in order to resolve the conflict.

One of the major benefits of version control is keeping track of all changes over time. If any changes are in conflict, or you decide it’s best to revert to an earlier version, you can go back to any previous version of your project at any point in time and restore it. 
 

Version control has major benefits for both solo developers and those working together on a team. Although it may seem intimidating to start, version control systems are powerful tools for maintaining a project as you work. In this tutorial, you:


Learned about basic version control theory.

Implemented that theory by setting yourself up to work within the GitHub ecosystem.

Set up version control

1. Overview

2. What is version control?

3. Who uses version control?

4. Select your version control tool

5. Get started with GitHub Desktop

6. Create a new repo on your hard drive

7. Download, open, and start tracking your project

8. Do an initial commit and publish your repo

9. How does version control work?

10. Summary

Complete this tutorial