Unity Game Engine Series Part 1: Unity Basics & Interface

1. Editor Overview

The Unity Editor is your command center for game development. Think of it as a film studio where you're simultaneously the director, cinematographer, set designer, and technical crew. Understanding each window and how they work together is fundamental to productive development.

1.1 Scene View vs Game View

Unity provides two fundamentally different viewports for working with your project:

1.2 Hierarchy, Inspector & Project Windows

Analogy: Think of Unity's panel layout as a construction project:

• Hierarchy = The blueprint/floor plan — shows every object in your current scene organized in a tree structure (parent-child relationships)
• Inspector = The spec sheet — when you select an object, the Inspector shows all its components and properties, letting you configure everything
• Project = The warehouse — contains all assets in your project (scripts, textures, models, audio, prefabs), organized in folders on disk
• Console = The site radio — displays messages, warnings, and errors from your scripts and the engine

1.3 Toolbar & Gizmos

The toolbar at the top of the editor provides essential transform tools:

Gizmos are visual debug helpers in the Scene View — icons for cameras, lights, audio sources, and custom gizmo drawings from your scripts. They're invisible in the Game View and final build. Think of them as the "X-ray vision" that reveals the invisible components powering your game.

2. Core Workflow

2.1 Creating & Managing Scenes

A Scene in Unity is a container for everything the player experiences at a given moment — think of it as a "level" or "screen." A typical game might have:

• MainMenu — Title screen, settings, level select
• Level_01, Level_02, ... — Gameplay levels
• Loading — Transition scene with progress bar
• GameOver — End screen

// Loading scenes programmatically in Unity
using UnityEngine;
using UnityEngine.SceneManagement;

public class SceneLoader : MonoBehaviour
{
    // Load a scene by name (must be added to Build Settings)
    public void LoadScene(string sceneName)
    {
        SceneManager.LoadScene(sceneName);
    }

    // Load a scene asynchronously (no freezing!)
    public void LoadSceneAsync(string sceneName)
    {
        StartCoroutine(LoadAsync(sceneName));
    }

    private System.Collections.IEnumerator LoadAsync(string sceneName)
    {
        // Begin async loading
        AsyncOperation operation = SceneManager.LoadSceneAsync(sceneName);
        operation.allowSceneActivation = false;

        while (!operation.isDone)
        {
            // Progress goes from 0 to 0.9 during loading
            float progress = Mathf.Clamp01(operation.progress / 0.9f);
            Debug.Log($"Loading progress: {progress * 100:F0}%");

            // Activate the scene when loading completes
            if (operation.progress >= 0.9f)
            {
                Debug.Log("Press any key to continue...");
                if (Input.anyKeyDown)
                    operation.allowSceneActivation = true;
            }

            yield return null;
        }
    }

    // Additive scene loading (load multiple scenes simultaneously)
    public void LoadAdditiveScene(string sceneName)
    {
        SceneManager.LoadScene(sceneName, LoadSceneMode.Additive);
    }
}

2.2 Play Mode vs Edit Mode

3. Asset Management

3.1 Import Pipeline

Unity's import pipeline automatically processes files you drop into the Assets folder. Each asset type has specific import settings:

3.2 Folder Structure Best Practices

# Recommended Unity project folder structure
Assets/
├── _Project/              # Your game's core assets (underscore keeps it at top)
│   ├── Art/
│   │   ├── Materials/
│   │   ├── Models/
│   │   ├── Textures/
│   │   └── Animations/
│   ├── Audio/
│   │   ├── Music/
│   │   ├── SFX/
│   │   └── Ambient/
│   ├── Prefabs/
│   │   ├── Characters/
│   │   ├── Environment/
│   │   ├── UI/
│   │   └── Effects/
│   ├── Scenes/
│   │   ├── MainMenu.unity
│   │   ├── Level_01.unity
│   │   └── Testing/          # Temporary test scenes
│   ├── Scripts/
│   │   ├── Core/             # Managers, singletons, game loop
│   │   ├── Player/           # Player controller, input, camera
│   │   ├── Enemies/          # AI, enemy behaviors
│   │   ├── UI/               # Menu scripts, HUD
│   │   └── Utilities/        # Helper classes, extensions
│   ├── ScriptableObjects/
│   │   ├── Items/
│   │   ├── Enemies/
│   │   └── Config/
│   └── Shaders/
├── Plugins/               # Third-party plugins
├── StreamingAssets/       # Files that need to be accessed at runtime by path
└── Resources/             # Assets loaded via Resources.Load (use sparingly!)

3.3 Asset Serialization

Every asset in Unity has a corresponding .meta file that stores its import settings and a unique GUID. These meta files are critical for version control:

Unity supports two serialization modes:

• Force Text (recommended) — Human-readable YAML format. Enables meaningful diffs in version control, easier merge conflict resolution
• Force Binary — Smaller file sizes, faster serialization, but impossible to diff or merge

4. Prefabs System

Prefabs are Unity's most powerful asset organization feature — reusable templates for GameObjects and their components. Think of a prefab as a cookie cutter: you design the shape once, and every cookie (instance) you stamp out shares the same base configuration, but you can add unique frosting (overrides) to individual ones.

4.1 Prefabs & Variants

// Working with prefabs in code
using UnityEngine;

public class EnemySpawner : MonoBehaviour
{
    [Header("Spawn Configuration")]
    [SerializeField] private GameObject enemyPrefab;    // Assign in Inspector
    [SerializeField] private Transform[] spawnPoints;
    [SerializeField] private float spawnInterval = 3f;
    [SerializeField] private int maxEnemies = 10;

    private int currentEnemyCount = 0;

    private void Start()
    {
        // Start spawning enemies on a timer
        InvokeRepeating(nameof(SpawnEnemy), 1f, spawnInterval);
    }

    private void SpawnEnemy()
    {
        if (currentEnemyCount >= maxEnemies) return;

        // Pick a random spawn point
        Transform spawnPoint = spawnPoints[Random.Range(0, spawnPoints.Length)];

        // Instantiate creates a new instance of the prefab
        GameObject enemy = Instantiate(
            enemyPrefab,
            spawnPoint.position,
            spawnPoint.rotation
        );

        // Optional: parent to a container for organization
        enemy.transform.SetParent(transform);
        enemy.name = $"Enemy_{currentEnemyCount}";
        currentEnemyCount++;
    }

    // Clean up when an enemy is destroyed
    public void OnEnemyDestroyed()
    {
        currentEnemyCount--;
    }
}

4.2 Nested Prefabs & Overrides

Nested prefabs (introduced in Unity 2018.3) allow you to compose complex objects from smaller, reusable building blocks. This is a game-changer for large projects:

5. Unity Architecture

5.1 Component-Based Design

Unity uses a component-based architecture rather than deep inheritance hierarchies. Every object in your game is a GameObject — an empty container — that gains behavior through attached Components.

Analogy: Think of a GameObject as a LEGO minifigure base. On its own, it's just a generic placeholder. Add a hat component and it's a pirate. Add a helmet and jetpack and it's an astronaut. Add a wand and cloak and it's a wizard. The base never changes — only the components attached to it define what it is and what it can do.

// Component-based design example
// Instead of: class FlyingBossEnemy : FlyingEnemy : Enemy : MonoBehaviour
// Use small, composable components:

// HealthComponent.cs — handles damage and death
public class HealthComponent : MonoBehaviour
{
    [SerializeField] private float maxHealth = 100f;
    private float currentHealth;

    public event System.Action OnHealthChanged;
    public event System.Action OnDeath;

    private void Awake()
    {
        currentHealth = maxHealth;
    }

    public void TakeDamage(float amount)
    {
        currentHealth = Mathf.Max(0, currentHealth - amount);
        OnHealthChanged?.Invoke(currentHealth / maxHealth);

        if (currentHealth <= 0)
            OnDeath?.Invoke();
    }
}

// MovementComponent.cs — handles movement
public class MovementComponent : MonoBehaviour
{
    [SerializeField] private float moveSpeed = 5f;
    [SerializeField] private bool canFly = false;

    public void Move(Vector3 direction)
    {
        Vector3 movement = direction.normalized * moveSpeed * Time.deltaTime;
        if (!canFly) movement.y = 0; // Ground-only movement
        transform.Translate(movement, Space.World);
    }
}

// Now compose your entities:
// Ground Enemy: HealthComponent + MovementComponent(canFly=false) + PatrolAI
// Flying Enemy: HealthComponent + MovementComponent(canFly=true) + FlyingAI
// Boss: HealthComponent(hp=1000) + MovementComponent(canFly=true) + BossAI + ShieldComponent

5.2 Script Lifecycle (Execution Order)

Understanding Unity's script lifecycle is essential — it determines when your code runs and in what order. Getting this wrong leads to null reference errors, race conditions, and mysterious bugs.

// Unity Script Lifecycle — Complete Example
using UnityEngine;

public class LifecycleDemo : MonoBehaviour
{
    private Rigidbody rb;
    private float horizontalInput;
    private float verticalInput;

    // 1. INITIALIZATION PHASE
    private void Awake()
    {
        // First to run — initialize self-references
        rb = GetComponent<Rigidbody>();
        Debug.Log("Awake: Component references cached");
    }

    private void OnEnable()
    {
        // Runs each time enabled — subscribe to events
        GameManager.OnGamePaused += HandlePause;
        Debug.Log("OnEnable: Events subscribed");
    }

    private void Start()
    {
        // Runs once after all Awakes — safe to reference other objects
        Debug.Log("Start: Cross-references safe to use");
    }

    // 2. GAME LOOP PHASE
    private void Update()
    {
        // Runs every frame — read input here
        horizontalInput = Input.GetAxisRaw("Horizontal");
        verticalInput = Input.GetAxisRaw("Vertical");

        // Frame-rate dependent logic
        transform.Rotate(0, horizontalInput * 120f * Time.deltaTime, 0);
    }

    private void FixedUpdate()
    {
        // Runs at fixed intervals — physics here
        Vector3 force = transform.forward * verticalInput * 10f;
        rb.AddForce(force);
    }

    private void LateUpdate()
    {
        // Runs after all Updates — camera/follow logic
        // Ensures we see the final position of this frame
        Debug.Log($"Final position this frame: {transform.position}");
    }

    // 3. CLEANUP PHASE
    private void OnDisable()
    {
        // Unsubscribe to prevent memory leaks
        GameManager.OnGamePaused -= HandlePause;
    }

    private void OnDestroy()
    {
        Debug.Log("OnDestroy: Object being removed from scene");
    }

    private void HandlePause(bool isPaused)
    {
        enabled = !isPaused;
    }
}

Exercises & Self-Assessment

Conclusion & Next Steps

You now have a solid foundation in Unity's editor, workflow, and architecture. Here are the key takeaways from Part 1:

• The Unity Editor is your command center — Scene View for building, Game View for testing, Hierarchy for structure, Inspector for configuration
• Play Mode changes are temporary — the most important rule for every Unity beginner
• Asset management matters — good folder structure and always committing .meta files prevents painful bugs
• Prefabs are your best friend — use them for reusable objects, variants for specialization, and nesting for composition
• Component-based design is Unity's core philosophy — compose behaviors from small, focused components instead of building deep inheritance chains
• Script lifecycle (Awake → Start → Update → FixedUpdate → LateUpdate) determines when your code runs — understanding this prevents the most common Unity bugs