Unity Editor Tour

Before we write a single line of game code, we need to be comfortable with the Unity editor itself. This chapter is your guided tour of every important panel, tool, and concept in the editor. Take your time here — you'll spend hundreds of hours in this environment, and knowing your way around will make everything faster.

Open your InfiniteRunner project in Unity Hub if it isn't already open. Make sure you've loaded the GameScene we created in the previous chapter.

The Scene View

The Scene View is the large 3D viewport in the center of the editor. This is your design workspace — where you place objects, build levels, and visually arrange everything in your game world. Think of it as looking through a floating camera that you control freely.

Navigating the Scene View

Navigating in 3D space can feel strange at first if you've never used a 3D application before. Here are the essential controls:

• Orbit (rotate the view around a point): Hold Alt + Left Mouse Button and drag. The view will rotate around the center of the screen. This is like walking around an object to see it from different angles.
• Pan (slide the view left/right/up/down): Hold Middle Mouse Button (click the scroll wheel) and drag. Alternatively, hold Alt + Middle Mouse Button. This slides the camera without rotating it.
• Zoom (move closer/farther): Scroll the mouse wheel up to zoom in, down to zoom out. You can also hold Alt + Right Mouse Button and drag up/down for finer control.
• Fly-through mode: Hold the Right Mouse Button and use WASD keys to fly around like a first-person game. Q moves down, E moves up. The scroll wheel adjusts fly speed. This is the fastest way to navigate large scenes.
• Focus on an object: Select an object in the Hierarchy, then press F (for "focus" or "frame"). The Scene View will zoom in and center on that object. Incredibly useful when you lose track of where something is.

Scene View Gizmos

In the top-right corner of the Scene View, you'll see a small gizmo — a colored cube with labeled axes (X, Y, Z). This shows your current orientation:

• Red (X) = left/right
• Green (Y) = up/down
• Blue (Z) = forward/back

You can click on any axis label on the gizmo to snap to that view. For example, clicking "Y" gives you a top-down view. Clicking "Z" gives you a front view. This is useful when you need precise alignment.

Scene View Toolbar

At the top-left of the Scene View, you'll see several tool buttons. These control what happens when you click and drag objects in the scene:

• Q — Hand Tool: Click and drag to pan the view. Same as middle-mouse panning.
• W — Move Tool: Shows colored arrows on the selected object. Drag an arrow to move the object along that axis. Red = X, Green = Y, Blue = Z.
• E — Rotate Tool: Shows colored circles around the selected object. Drag a circle to rotate around that axis.
• R — Scale Tool: Shows colored cubes on each axis. Drag to scale the object along that axis. Drag the center cube to scale uniformly.
• T — Rect Tool: A 2D-focused tool for UI elements. We'll use this when building our UI system.
• Y — Transform Tool: Combines Move, Rotate, and Scale into one gizmo.

The Game View

The Game View shows exactly what the player will see when they play your game. It renders through the Main Camera in your scene. While the Scene View is your design workspace, the Game View is your preview window.

You can find the Game View as a tab next to the Scene View. Click on the "Game" tab to switch to it. When you're not in Play Mode, the Game View shows a static preview. When you press Play, it becomes a live, interactive view of your running game.

Resolution and Aspect Ratio

At the top of the Game View, you'll see a dropdown that says something like "Free Aspect" or "1920x1080." This controls the resolution and aspect ratio of the preview. For our infinite runner, we'll want to test at common mobile resolutions:

• Click the dropdown and select "+" to add a custom resolution.
• For a portrait mobile game (like Subway Surfers), add 1080 x 1920 (9:16 portrait).
• For landscape, add 1920 x 1080 (16:9 landscape).
• You can switch between these any time to see how your game looks at different sizes.

The Hierarchy

The Hierarchy panel (usually on the left side) shows a list of every GameObject in the currently loaded scene. Right now, your GameScene should have two objects:

• Main Camera — The virtual camera through which the player sees the world.
• Directional Light — A light source that simulates the sun, casting light in one direction across the entire scene.

What Is a GameObject?

In Unity, everything in your scene is a GameObject. The camera is a GameObject. Lights are GameObjects. Your player character will be a GameObject. Obstacles, coins, UI elements, invisible trigger zones — all GameObjects. A GameObject is just a container. By itself, it does nothing. It becomes useful when you add components to it (more on that in the Inspector section below).

Creating GameObjects

Let's create a simple object so we have something to work with. We'll create a cube:

1. Right-click in an empty area of the Hierarchy panel.
2. Choose 3D Object → Cube.
3. A cube appears in both the Scene View and the Hierarchy. It's selected by default (highlighted in blue in the Hierarchy).

You now have three objects in your Hierarchy. Try clicking on each one to select it. Notice how the Scene View highlights the selected object and the Inspector on the right updates to show its properties.

Parent-Child Relationships

GameObjects can be organized into parent-child hierarchies. When you drag one object onto another in the Hierarchy, it becomes a child of that object. Child objects:

• Move with their parent. If you move the parent, all children move with it, maintaining their relative position.
• Rotate with their parent. Rotating the parent rotates all children around the parent's pivot point.
• Scale with their parent. Scaling the parent scales all children proportionally.
• Their Transform values become relative to the parent, not the world. A child at position (0, 1, 0) is 1 unit above its parent, regardless of where the parent is in the world.

We'll use parent-child relationships extensively. For example, our player character will be a parent object with child objects for the body mesh, particle effects, and collision shapes.

The Inspector

The Inspector panel (usually on the right side) shows the details of whatever object you have selected. It displays all the components attached to a GameObject and lets you edit their properties.

Click on the Cube you created earlier. The Inspector should show:

The Transform Component

Every single GameObject has a Transform component. It cannot be removed. The Transform defines three things:

• Position — Where the object is in 3D space, expressed as three numbers: X (left/right), Y (up/down), Z (forward/back). By default, new objects are placed at (0, 0, 0), which is called the origin.
• Rotation — How the object is rotated, in degrees, around each axis. (0, 0, 0) means no rotation.
• Scale — How large the object is along each axis. (1, 1, 1) means normal size. (2, 2, 2) means twice as big in all directions.

Try changing the cube's position. In the Inspector, find the Position row under Transform. Click on the number next to Y and change it from 0 to 3. Press Enter. Watch the cube in the Scene View — it moved up. Change it back to 0.

Other Components on the Cube

Below Transform, the cube has several other components:

• Mesh Filter — Defines the shape of the object (in this case, a cube mesh). This is the 3D geometry.
• Mesh Renderer — Makes the mesh visible by rendering it with a material. Without this, the cube would exist but be invisible.
• Box Collider — Defines the cube's collision shape for the physics system. This is how Unity knows when objects bump into each other.

Adding Components

You can add new components to any GameObject by clicking the "Add Component" button at the bottom of the Inspector. This is how you give objects new abilities. For example, adding a Rigidbody component makes an object respond to gravity and physics. Adding a script component lets you control the object with your own C# code.

Let's try it:

1. Make sure the Cube is selected.
2. In the Inspector, click "Add Component."
3. Type "Rigidbody" in the search box.
4. Click "Rigidbody" (not "Rigidbody 2D" — we're working in 3D).
5. Now press Play. The cube falls! That's gravity. The Rigidbody component told Unity's physics engine to apply gravity to this object.
6. Press Play again to stop.

The Project Window

The Project window (usually at the bottom of the editor) is your file browser. It shows every file and folder inside your project's Assets directory. This is where you'll find and organize scripts, scenes, prefabs, materials, textures, audio files, and everything else.

Key Things to Know

• Everything lives in Assets. All your project files must be inside the Assets folder. Unity ignores files outside of it.
• Create folders to stay organized. Right-click in the Project window and choose Create → Folder. We'll set up a proper folder structure in Chapter 5.
• Never move Unity files outside of Unity. If you need to rename, move, or delete a file, do it in the Project window, not in Windows Explorer or macOS Finder. Unity tracks files using .meta files (hidden companion files). Moving files outside Unity breaks these references, causing errors.
• Search is powerful. The search bar at the top of the Project window can find any file by name. You can also filter by type (e.g., t:Script to show only scripts, t:Material to show only materials).
• Drag-and-drop works. You can drag files from your operating system's file browser into the Project window to import them. This is how you'll add art, audio, and other assets.

The Console

The Console panel shows messages, warnings, and errors from Unity and your scripts. If you don't see it, open it with Window → General → Console. It typically shares a tab with the Project window at the bottom of the editor.

Types of Console Messages

• White messages (Log): Informational messages you've written with Debug.Log(). These are for your own debugging purposes. Unity doesn't generate these — only your code does.
• Yellow messages (Warning): Something isn't quite right but the game can still run. You can write these with Debug.LogWarning(). Unity also generates warnings when it detects potential issues.
• Red messages (Error): Something is broken. Your code has a compile error, a null reference, or some other problem. Written with Debug.LogError() or generated by Unity when things crash. Always fix red errors before moving on.

using UnityEngine;

public class ConsoleExample : MonoBehaviour
{
    void Start()
    {
        // These three lines demonstrate the different console message types
        Debug.Log("This is a regular message.");        // White
        Debug.LogWarning("This is a warning.");          // Yellow
        Debug.LogError("This is an error!");             // Red
    }
}

Console Toolbar

At the top of the Console, you'll see toggle buttons for each message type. You can click them to filter which messages are shown. There's also:

• Clear — Clears all messages from the console.
• Collapse — Groups identical messages together instead of showing each one separately. Useful when a message is being printed every frame (60 times per second).
• Error Pause — Automatically pauses the game when an error occurs. Extremely useful for debugging.

GameObjects and Components: The Core Concept

This is the single most important concept in Unity, so we're going to make sure it's crystal clear.

Unity uses a component-based architecture. This means:

• A GameObject is an empty container. By itself, it has no behavior, no appearance, no purpose.
• Components are the building blocks that give a GameObject its abilities. Attach a Mesh Renderer and it becomes visible. Attach a Rigidbody and it responds to physics. Attach a C# script and it does whatever you program it to do.
• A single GameObject can have many components. Your player character, for example, will have a Transform (position), a Mesh Renderer (appearance), a Rigidbody (physics), a Collider (collision), and several custom scripts (behavior).

Think of it like building with LEGO. The GameObject is the base plate. Each component is a LEGO brick you snap on. A camera brick makes it see. A light brick makes it glow. A script brick makes it think.

Common Built-in Components

The Transform Component: Position, Rotation, Scale

Since the Transform is on every single object and we'll interact with it constantly, let's understand it deeply.

Position

Position is measured in units. One Unity unit typically represents one meter, though you can decide your own scale. Position has three values:

• X — Horizontal axis (left is negative, right is positive).
• Y — Vertical axis (down is negative, up is positive).
• Z — Depth axis (back is negative, forward is positive).

In our runner, the player will run along the Z axis (forward). Lanes will be offset along the X axis (left/right). Jumping changes the Y axis (up/down).

Rotation

Rotation is measured in degrees (0 to 360) around each axis. Rotating 90 degrees around the Y axis turns the object to face sideways. Rotation can be tricky to think about — for now, just know it exists. We'll manipulate it more when we work with the player character.

Scale

Scale defines the object's size relative to its default. A scale of (1, 1, 1) is normal size. A scale of (2, 1, 1) makes it twice as wide but normal height and depth. A scale of (0.5, 0.5, 0.5) makes it half-size in all directions.

Accessing Transform from Code

In C# scripts (which we'll start writing in the next chapter), you access the Transform like this:

using UnityEngine;

public class TransformExample : MonoBehaviour
{
    void Start()
    {
        // Read the current position
        Vector3 pos = transform.position;
        Debug.Log("I am at: " + pos);

        // Move the object to a new position
        transform.position = new Vector3(0f, 5f, 10f);

        // Move the object relative to its current position
        transform.Translate(Vector3.forward * 2f);

        // Rotate 90 degrees around the Y axis
        transform.Rotate(0f, 90f, 0f);
    }
}

Don't worry about understanding every line right now. We'll cover C# in depth in the next chapter. The key takeaway is that transform (lowercase) is available in every script and gives you direct access to the object's position, rotation, and scale.

Play Mode: Testing Your Game

At the top center of the Unity editor, you'll find three buttons:

• Play (triangle): Starts your game. The Game View activates and your scripts begin running.
• Pause (two vertical lines): Pauses the game mid-play. Useful for inspecting objects during gameplay.
• Step (triangle with a line): Advances the game by exactly one frame. Useful for debugging frame-by-frame.

The keyboard shortcut for Play/Stop is Ctrl+P (Windows) or Cmd+P (Mac).

The Play Mode Tint

When Play Mode is active, Unity tints the editor slightly (usually a subtle color change around the edges). This visual cue reminds you that you're in Play Mode and any changes are temporary. You can customize this tint color in Edit → Preferences → Colors → Playmode tint. Many developers set it to a strong red or blue so they never accidentally make changes in Play Mode.

Essential Keyboard Shortcuts

Here are the shortcuts you'll use most frequently. Memorize these — they'll save you hours over the course of this project:

Common Beginner Mistakes (and How to Avoid Them)

Every Unity beginner hits the same walls. Knowing about these pitfalls in advance will save you hours of frustration. Read through each one carefully — you will encounter most of these during this course.

1. "My changes disappeared!" — Editing in Play Mode

This is the number one beginner frustration in Unity. When you press the Play button, the editor enters Play Mode. While Play Mode is active, you can move objects, tweak values, add components — and everything appears to work. But the moment you press Stop, every single change you made is erased. Unity reverts the entire scene to the state it was in before you pressed Play.

This isn't a bug — it's by design. Play Mode is a sandbox for testing. It lets you experiment freely without risk of breaking your project. But if you don't know about it, you'll spend 20 minutes carefully positioning objects, press Stop to take a break, and watch all your work vanish.

Solution: Always stop Play Mode before making permanent changes. If you discover a perfect value during testing (say, a jump height of 7.5), write it down on paper or in a note before pressing Stop, then apply it afterwards.

2. "My script doesn't do anything!" — Script Not Attached

Creating a C# script file in the Project window is only step one. A script that just sits in your Assets folder will never execute. None of its methods — Awake(), Start(), Update() — will ever be called. For a script to run, it must be attached to a GameObject as a component.

How to attach a script:

1. Select a GameObject in the Hierarchy.
2. In the Inspector, click Add Component at the bottom.
3. Type the name of your script in the search box.
4. Click the script name when it appears in the results.

The script now appears as a component in the Inspector, and Unity will call its lifecycle methods.

3. "I can't find my file!" — Lost in the Project Window

As your project grows, you'll accumulate dozens of scripts, prefabs, materials, and other assets across many folders. It's easy to lose track of where things are.

Solution: Use the search bar at the top of the Project window. It searches recursively through all subfolders. You can also filter by type using special prefixes:

• t:Script — Shows only C# scripts
• t:Prefab — Shows only prefabs
• t:Material — Shows only materials
• t:Scene — Shows only scene files
• t:Texture — Shows only textures and images

You can combine type filters with a name search. For example, t:Script Player will show all scripts with "Player" in the name.

4. "Everything looks different from the tutorial!" — Layout Changes

Unity's panels (Scene, Game, Hierarchy, Inspector, Project, Console) can all be dragged, resized, docked, and rearranged. It's easy to accidentally drag a panel somewhere unexpected, or close a panel entirely. When your layout no longer matches what you see in a tutorial, it can be very disorienting.

Solution: Go to Window → Layouts → Default to reset the editor layout to Unity's default arrangement. Everything will snap back to its standard position. You can also save your own custom layouts once you find an arrangement you like: Window → Layouts → Save Layout, give it a name, and you can recall it any time.

5. "I see pink/magenta objects!" — Missing Materials

If an object in your scene appears as a flat, bright pink or magenta color, it means Unity cannot find the material or shader assigned to that object. The pink color is Unity's way of saying "I don't know how to render this."

This typically happens when:

• You imported assets from a package or the Asset Store that were made for a different render pipeline (e.g., assets made for the Built-in Render Pipeline used in a URP project).
• A material file was deleted or moved outside of Unity.
• A shader that the material depends on is missing or has errors.

Solution: Select the pink object. In the Inspector, find the Mesh Renderer component and look at the Materials section. You can drag a valid material from the Project window onto the material slot. If many objects are pink after switching render pipelines, use Edit → Rendering → Materials → Convert Built-in Materials to URP (or the equivalent for your pipeline).

6. "My object is there but I can't see it!" — Common Visibility Issues

You've added an object to the scene. It shows up in the Hierarchy. But it's nowhere to be seen in the Scene or Game View. This is surprisingly common and usually has a simple cause:

• Check the Position: Look at the Transform in the Inspector. Is the object at a reasonable position? It might be thousands of units away from the camera. Select the object and press F in the Scene View to focus on it.
• Check the Scale: Is the Scale set to (0, 0, 0)? A zero-scale object exists but is infinitely small — invisible. Reset the scale to (1, 1, 1).
• Check the Mesh Renderer: In the Inspector, find the Mesh Renderer component. Is the checkbox next to its name enabled? If the checkbox is unchecked, the renderer is disabled and the object won't be drawn.
• Check for obstruction: Another object might be in front of it. The object might also be inside another object at the same position.

Chapter Summary

You now know your way around the Unity editor. Here's what we covered:

• Scene View — Your 3D design workspace. Navigate with Alt+click (orbit), middle-mouse (pan), scroll wheel (zoom), and right-click+WASD (fly-through).
• Game View — Preview of what the player sees. Set resolution for testing different screen sizes.
• Hierarchy — Lists every GameObject in the scene. Supports parent-child relationships.
• Inspector — Shows components and properties of the selected object. Add components to give objects new abilities.
• Project Window — File browser for all assets. Never move files outside of Unity.
• Console — Shows logs, warnings, and errors. Check it every time you press Play.
• GameObjects + Components — Unity's core architecture. GameObjects are containers; components give them behavior.
• Transform — Position, Rotation, Scale. On every object, always.
• Play Mode — Tests your game. Changes made during Play Mode are temporary!
• Common Beginner Mistakes — Play Mode edits vanishing, scripts not attached, missing materials (pink objects), lost files, layout issues, and invisible objects.

You can now navigate the editor, create objects, add components, and test your game. In the next chapter, we'll learn the programming language that powers everything: C#.