Unity 6 - Complete Beginners Tutorial (2025)

Main ideas / concepts covered

• Unity 6 beginner walkthrough to create a very simple 3D game “from scratch.”
• Core Unity workflow:
  • Install and open Unity Hub and the Unity Editor
  • Create a new project
  • Use Unity’s key panels:
    • Scene (workspace/viewport)
    • Hierarchy (scene objects)
    • Inspector (component settings)
    • Project window (assets/folders)

Building blocks of the tutorial game

• GameObjects: ground, player, coins, and an empty spawner
• Components:
  • Transform, Mesh Filter, Mesh Renderer
  • Box Collider, Rigidbody
  • Camera behavior
• Materials: colors and surface smoothness for objects
• Prefabs: a coin template used to spawn many coins efficiently
• Scripts: C# behaviors using Unity lifecycle functions
• Colliders & triggers: detect coin pickups

Basic gameplay loop created

• A spawner generates many coins across the ground area
• The player moves using keyboard input
• The camera follows smoothly
• The player collects coins:
  • coins are destroyed
  • points increase

---

Methodology / step-by-step instructions (detailed)

1) Setup and project creation

• Ensure Unity Hub and Unity Editor are installed.
• In Unity Hub:
  1. Click New Project
  2. Use template category Universal 3D
  3. Name the project (e.g., “tutorial”)
  4. Disable Unity Version Control
  5. Create the project

2) Understand the Unity editor layout

• Inspector: shows settings/components for the selected object (e.g., Transform, Camera)
• Hierarchy: lists all GameObjects in the current scene
• Scene tab: workspace/viewport for editing and arranging objects
• Project window: manages assets (models, textures, scripts, materials, prefabs)

3) Create the ground (and configure it)

• In Hierarchy:
  • Right-click → 3D Object → Cube
• Rename the cube (tutorial refers to it as “round”).
• Set Transform position:
  • X = 0, Y = 0, Z = 0
• Adjust Scale to make a wide ground:
  • X = 20, Y unchanged, Z = 20
• Use mouse controls to position/rotate/scale as needed:
  • scroll/drag for scene navigation
  • arrow keys for movement
  • snapping when holding Control

4) Create the player

• In Hierarchy:
  • Right-click → 3D Object → Cube
• Rename to player
• Set Transform so it sits on top of the ground:
  • X = 0, Y = 1, Z = 0 (as stated in subtitles)
• Notes:
  • Unity automatically adds a Box Collider to cubes.
  • Ground and player aren’t differentiated for gameplay logic yet.

5) Create materials to visually distinguish objects

• In Project window:
  • Create folder materials
• Create materials:
  • player (red)
  • ground (green/grass-like)
  • coin gets its own material (very high smoothness)
• Apply materials:
  • Drag ground material onto the ground
  • Drag player material onto the player
• Adjust Smoothness as suggested:
  • Ground: set to an appropriate option (tutorial references “katun grass”/correct smoothness)
  • Player: smoothness 0
  • Coin: smoothness around 100 (very shiny)

6) Create a coin (and convert it to a prefab)

• In Hierarchy:
  • Right-click → 3D Object → Cube (use as the coin)
• Rename to coin
• Apply coin material
• Move the coin so it doesn’t overlap the player; optionally scale it down:
  • tutorial shrinks it to about half the player size
• Normalize its position (set axes values as described in the tutorial)
• For mass placement:
  • Create folder prefabs
  • Drag the coin object into prefabs to make it a coin prefab
  • Remove the original coin from the scene after creating the prefab (so spawning uses the template)

7) Create a coin spawner object

• In Hierarchy:
  • Right-click → Create Empty
• Rename to coin spawner
• Set its transform to 0, 0, 0 (invisible spawner anchor point)

8) Write the Coin Spawner script (spawn many coins)

• Add a component and create a script:
  • Name: coin spawner
• Key Unity lifecycle concepts taught:
  • Awake: runs before Start (initialization)
  • Start: runs once (spawn coins once here)
  • Update: runs every frame
  • FixedUpdate: physics timing (not required yet for coin spawning)

Script structure (conceptual)

• Use serialized fields so values can be set in the Inspector:
  • coin prefab (private, but visible via serialized field)
  • ground collider (reference to the ground’s Box Collider)
  • coin amount (e.g., 10/20)

Spawning logic (in Start)

• Loop from 0 to coin amount
• Spawn each coin at a randomized point within the ground collider bounds
• Random placement approach:
  • compute random X and Z within collider bounds
  • keep Y fixed (tutorial returns Y = 1 so coins sit on top)

Unity setup and test

• Drag references into the script fields:
  • ground’s Box Collider → ground collider field
  • coin prefab → coin prefab field
• Set coin amount (e.g., 10 or 20)
• Press Play:
  • coins should appear inside the collider area (e.g., 20 coins)

9) Write the Player movement script

• On the player object:
  • Add component
  • Create script (tutorial: player Handler)
• Add required references/values:
  • Rigidbody reference
  • player speed
  • Initialize Rigidbody in Awake by grabbing the component from the object
• Movement logic:
  • Use FixedUpdate (physics-friendly)
  • Read input:
    • Horizontal axis + vertical axis (WASD / arrow keys)
  • Create a movement vector in X/Z plane (don’t change Y)
  • Move Rigidbody position:
    • rigidbody.position + movement * playerSpeed * fixedDeltaTime

10) Add and configure a following camera

• Create a camera behavior script (tutorial: follow player)
• Key fields:
  • Target (target)
  • Offset (distance from target)
  • Smooth time (how quickly smoothing catches up)
  • Velocity reference for smoothing
• Use FixedUpdate to update camera smoothly:
  • compute target position + offset
  • smooth between current and target camera position using SmoothDamp
  • make the camera look at the target/player position
• Configure in Unity:
  • set camera target to the player
  • set Y height offset and Z distance offset (as described)

11) Make coins collectible using trigger collisions

• In coin prefab:
  • set coin collider Is Trigger = true
• Create Coin script (tutorial: coin new script)
• Use OnTriggerEnter:
  • when something enters:
    • check if the other collider has player Handler
    • if present:
      • call playerHandler.increasePoints()
      • destroy the coin so it can’t be collected again

12) Track and display points

• In player Handler:
  • create points variable
  • ensure it is increased by increasePoints()
• Tutorial note:
  • points may be private unless marked serialized, so you might need debug visibility for private variables
  • in debug mode, points increase after collecting coins

---

Lessons / outcomes emphasized

• You can build a first playable 3D prototype quickly by combining:
  • Scene objects + components
  • Materials for clarity
  • Prefabs for scalable spawning
  • Scripts for behavior (spawning, movement, camera follow, pickups)
  • Triggers/colliders for interactions
• The tutorial stays minimal but functional:
  • spawn many coins
  • move the player
  • smooth follow camera
  • collect coins to increase points

---

Speakers / sources featured

• The video narrator / instructor (no specific name given in subtitles)
• Unity (engine/editor + Unity lifecycle concepts), including functions and components like:
  • Start/Awake/FixedUpdate
  • colliders
  • prefabs