The Unity Tutorial For Complete Beginners

Main ideas / lessons conveyed

• A practical way to learn Unity: don’t rely on long, passive tutorials; use a structured, hands-on approach.
• A reusable beginner workflow (“3-step technique”):
  1. Learn absolute Unity basics needed for almost any game.
  2. Practice with simple exercises to cement those basics.
  3. Build up the rest as you go, while developing an actual project.
• Core Unity concepts demonstrated by building Flappy Bird:
  • How Unity is organized: Project, Hierarchy, Inspector, Scene/Game view
  • How gameplay objects are built: GameObjects + Components (everything is a GameObject; features are components)
  • How to use physics, colliders, and scripts (C#)
  • How to write frame-based logic in Start vs Update, and gate actions with if statements
  • How to design consistent motion across devices using Time.deltaTime
  • How to create systems that spawn/move/delete objects using prefabs and timers
  • How to build UI and update it from scripts
  • How to use collisions vs triggers and connect systems via references and runtime lookup (tags + GetComponent)
  • How to implement a basic fail state and restart with UI buttons
  • How to generalize scoring and logic using function parameters and state variables (like a boolean)

---

Methodology / instruction list (detailed bullets)

1) Learning plan (the video’s approach)

• Learn only the core Unity fundamentals you’ll need for most games, such as:
  • Displaying and moving a character
  • Spawning objects and deleting them
  • Collisions, game-over logic
  • Animations and sound effects
• Cement knowledge with small exercises
• Continue learning while building a real game, fixing problems as they arise

---

2) Setup and project creation

• Download and install:
  • Unity Hub
  • Unity Editor (example used: 2021.3)
  • Visual Studio with workload: game development with Unity
• Create a new Unity project:
  • Choose 2D, Core
  • Start with an empty/2D-suitable template

---

3) Build Step 1: Understand UI + render the bird

• Learn Unity’s default panels:
  • Project panel: assets/scripts/sounds/etc.
  • Hierarchy: all GameObjects in the current scene
  • Inspector: modify selected GameObjects/components
  • Scene view / Game view: edit vs runtime camera view
• Create the bird:
  • Add an empty GameObject in the Hierarchy (Create Empty)
  • Name it Bird
  • Add components:
    • Sprite Renderer
      • Assign the bird sprite from the Project panel
• Adjust view and camera:
  • Use camera GameObject properties to “zoom out”
  • Optionally set Game view resolution/aspect ratio (example: 1920×1080)
• Press Play to verify the bird appears

---

4) Build Step 2: Make the bird physics-based and respond to spacebar

• Add physics components to the bird:
  • Rigidbody 2D
    • Enables gravity (bird falls when playing)
  • Circle Collider 2D
    • Configure collider position/offset
    • Design trick: slightly smaller collider for “leniency/fairness”
• Create a script:
  • New Script named BirdScript (C#)
  • Understand:
    • Start() runs once
    • Update() runs every frame
• Establish communication between script and components:
  • Add a reference variable, e.g.:
    • public Rigidbody2D myRigidbody;
  • In Unity Inspector:
    • Drag the Rigidbody2D component into that field
• Implement flapping:
  • In Update(), use if to respond only when space is pressed:
    • if (Input.GetKeyDown(KeyCode.Space)) { ... }
  • Set rigidbody velocity upward:
    • Use a vector like Vector2.up (direction)
    • Multiply by a power value
• Improve tunability:
  • Add a public variable:
    • public float flapStrength;
  • Use it instead of a hardcoded number (so you can tweak in Inspector)
• Recap key coding rules from this section:
  • Scripts can’t automatically access other components without references
  • Use if to conditionally run code
  • Use public variables for Inspector tuning (and note changes may not persist after stopping Play)

---

5) Build Step 3: Pipes move, spawn repeatedly, and despawn

A) Create pipe objects

• Create a parent GameObject called pipe
  • Add Sprite Renderer (for the parent pipe visuals)
  • Add collider(s)
• Create child objects:
  • top pipe (child)
    • Add Sprite Renderer + BoxCollider2D
  • Duplicate to create bottom pipe
    • Flip vertically via Y scale = -1
• Add movement script to the pipe parent:
  • Move left every frame using transform.position
  • Use Vector3 for position changes (even in 2D)
  • Fix inconsistent speed across frame rates:
    • Multiply movement by Time.deltaTime

B) Convert pipe to a prefab

• Drag pipe from Hierarchy into Project to create a prefab
• Delete the original pipe from the scene (keep prefab)

C) Spawn pipes on an interval (timer system)

• Create a GameObject Pipe Spawner
• Add a script (conceptually “Pipe Spawner” controller):
  • Public prefab reference:
    • public GameObject pipe;
  • Spawn using Unity’s instantiation:
    • Instantiate(...)
  • Add variables:
    • spawnRate (seconds between pipes)
    • timer (counts up each frame)
• Use an if/else style timer gate:
  • If timer < spawnRate:
    • increment timer by Time.deltaTime
  • Else:
    • spawn a pipe
    • reset timer to 0
• Avoid duplicating code:
  • Put spawn logic inside a function:
    • void spawnPipe() { Instantiate(...); }
  • Call spawnPipe() in:
    • Start() (spawns immediately)
    • Update() when timer triggers

D) Randomize pipe heights

• Add a public heightOffset
• Compute bounds:
  • lowestPoint = transform.position.y - heightOffset
  • highestPoint = transform.position.y + heightOffset
• When instantiating, set Y to:
  • Random.Range(lowestPoint, highestPoint)
• Keep X aligned with spawner; keep Z = 0

E) Despawn pipes when off-screen

• In the pipe movement script:
  • Add a deadZone X threshold (example: around -45)
  • If pipe transform.position.x < deadZone:
    • Destroy(gameObject) to free memory and stop updates
  • Optional debug:
    • Debug.Log("Pipe Deleted");
    • View messages in the Console panel

---

6) Score system + UI

A) Create UI text

• Add Canvas and Text (under UI)
• Set Canvas Scaler:
  • Scale with screen size
  • Reference resolution (example: 1080p)
• Prefer UI RectTransform sizing (change width/height rather than scale)

B) Logic manager for score

• Create GameObject Logic Manager
• Add script LogicScript (or similar)
• Include:
  • int score (integer)
  • A reference to UI text component
  • Add using UnityEngine.UI; to access UI types
• Provide a public function:
  • public void addScore(int scoreToAdd) (concept)
  • Update score:
    • score += scoreToAdd
  • Update UI text:
    • convert int to string with .ToString()

C) Trigger-based scoring when bird passes pipes

• Add a “middle” trigger collider on the pipes:
  • Create GameObject middle inside the pipe prefab
  • Add BoxCollider2D
  • Enable Is Trigger
• Add a pipe-middle script with OnTriggerEnter2D
• Since spawned pipes don’t exist in the scene ahead of time:
  • Use runtime lookup via tags:
    • Create a tag like Logic
    • Assign tag to the Logic Manager GameObject
  • In Start() of the pipe-middle script:
    • GameObject.FindGameObjectWithTag("Logic")
    • then .GetComponent<LogicScript>() to get script reference
• When the trigger is entered:
  • call logic.addScore(...)

D) Ensure only the bird scores

• Put bird and detect collision layers:
  • Assign bird to a dedicated Layer (e.g., “Bird”)
  • In pipe-middle trigger code:
    • check collided object’s layer matches the bird layer before calling addScore

E) Recap from this section

• UI is just another GameObject with components
• Use using UnityEngine.UI; for UI scripting
• Use tags + runtime FindGameObjectWithTag + GetComponent when you can’t drag references in the editor
• Use triggers for “passed through” scoring
• Use parameters (like scoreToAdd) to keep code flexible

---

7) Fail state (game over) + restart

A) Create game over UI

• In the Canvas:
  • Create parent Game Over Screen
  • Add Text (“Game Over”)
  • Add a Button
• Disable it initially

B) Restart button behavior

• In LogicScript:
  • Add a public restartGame() function:
    • Use using UnityEngine.SceneManagement;
    • Reload current scene:
      • SceneManager.LoadScene(SceneManager.GetActiveScene().name)
• Connect Button OnClick:
  • Drag Logic Manager into the button event
  • Select restartGame

C) Trigger game over on collision

• In bird script:
  • Listen for collision with pipes using OnCollisionEnter2D
• Call:
  • logic.gameOver() which enables the Game Over Screen UI
• Prevent flapping after death:
  • Add bool birdIsAlive = true
  • Set to false on collision
  • Update input logic:
    • only allow spacebar flap if birdIsAlive == true

D) Build the game

• File → Build Settings → Build
• Run the built executable

---

Concrete next steps / exercises suggested (post-tutorial)

• Add game over if the bird goes off-screen
• Fix a bug where score can keep increasing after game over
• Add sound effects:
  • Add Audio Source to Logic Manager
  • Play sound when score increments
• Add particle effects (e.g., clouds)
• Add bird flapping animation in Animation window
• Add a title screen scene:
  • Create a new scene and add it to Build Settings
• Challenge:
  • Use PlayerPrefs to save and display a high score
• Then expand creativity:
  • Suggest adding features like missiles/targets (example concept)
• Practice the same technique on other games:
  • Pong, Space Invaders, Breakout, Pop the Lock, Angry Birds variants, WarioWare mini games, and the Chrome dinosaur game

---

Speakers / sources featured

• Mark (the video author/instructor; explicitly identified as “Hi, my name is Mark.”)
• Unity documentation (referenced as a learning resource)
• GMTK (mentioned as the channel/brand; “click here… episode one of Developing”; patrons support GMTK)
• Patrons (credited for preventing mid-roll ads)