🎮 Unity Intermediate

You've shipped a mini-game. Now build like a pro. This is the sequel to Unity Fundamentals — 47 lessons across 12 modules that take you from "I can make things move" to animation state machines, decoupled architecture, real game systems, production graphics, and a complete 2D toolkit. Every module ends in its own focused mini-project.

📚 About This Course

Fundamentals got you comfortable in Unity. Intermediate gets you fluent. We assume you already know your way around the Editor, GameObjects and components, basic C# scripting, physics, and simple UI — so we don't re-teach those. Instead, every lesson pushes into the systems and techniques that separate a first project from a shippable game.

The course is deliberately broad. Alongside the core skills — animation, architecture, input, UI, scenes, and shipping — there are three dedicated deep-dive tracks, each two modules long: a Systems track (AI navigation, combat & inventory), a Graphics track (lighting & shaders, VFX & cinematics), and a full 2D track (essentials, then animation & lighting). Take them in order or jump to the track you need.

As in Fundamentals, every render of the game world is a real image captured from Unity 6. Unity's visual node editors — the Animator, Shader Graph, VFX Graph, and Timeline — are drawn as faithful, labelled diagrams reconstructed from real setups, because those windows can't be screenshotted cleanly. What you see here matches what you'll build on your screen.

🆕 A deliberate upgrade: the new Input System

Fundamentals used Unity's legacy Input class to keep things simple. This course teaches the new Input System properly — Action Maps, device-agnostic bindings, and runtime rebinding — the approach modern Unity projects are built on. Module 3 covers the switch in full.

What You'll Learn

Drive characters with the Animator — states, transitions, blend trees, and animation events
Architect decoupled games with interfaces, C# events, and ScriptableObjects
Build device-agnostic controls with the new Input System, including rebinding
Ship real UI: menus, pause, live HUDs, health bars, and world-space elements
Manage scenes and persist progress with PlayerPrefs and JSON save files
Give enemies AI with the NavMesh and a patrol/chase/attack state machine
Build combat and inventory systems that scale
Light scenes, author Shader Graph materials, and add VFX, post-processing, and Timeline cutscenes
Work fluently in 2D — sprites, tilemaps, 2D physics, sprite animation, and 2D lights
Profile, pool, optimize, and produce a shippable build

Who This Course Is For

Graduates of Unity Fundamentals (or equivalent experience) ready for the next step
Developers who can write basic C# and want to build real game systems
Anyone who has made a small Unity project and hit the "how do the pros structure this?" wall
Hobbyists and students moving from following tutorials to designing their own architecture

🎓 New to Unity?

Start with Unity Fundamentals first. This course picks up exactly where it leaves off and assumes that groundwork.

📖 Course Modules

47 lessons across 12 modules. The core path runs start to finish; the three deep-dive tracks (Systems, Graphics, 2D) are flagged so you can prioritise what you need.

Module 1: Animation

Bring characters and objects to life with the Animator — state machines, blending, and animation-driven events.

Module 2: Architecture & ScriptableObjects

Stop wiring everything by hand. Decouple your game with interfaces, events, and data-driven ScriptableObjects.

Module 3: The New Input System

Retire the legacy Input class. Build device-agnostic controls with Action Maps, callbacks, and runtime rebinding.

Module 4: Advanced UI

Build the interfaces real games ship with — menus, a pause system, live HUDs, and UI anchored in the world.

Module 5: Scene Management & Persistence

Move between scenes without hitches and make progress stick — additive loading, PlayerPrefs, and a JSON save system.

Module 6: AI & Navigation Systems Track

Give enemies a brain: bake a NavMesh, drive agents, and build a patrol/chase/attack state machine.

Module 7: Combat & Inventory Systems Track

Health and damage through interfaces, hit detection, and a ScriptableObject-driven inventory.

Module 8: Lighting & Shaders Graphics Track

Make your scenes look intentional: URP lighting, baked lightmaps, and your first Shader Graph.

Module 9: VFX & Cinematics Graphics Track

Add spectacle: particle systems, the GPU-driven VFX Graph, post-processing, and Timeline cutscenes.

Module 10: 2D Essentials 2D Track

Everything shifts in 2D: sprites and sorting, sprite sheets, tilemaps, and 2D physics.

Module 11: 2D Animation & Lighting 2D Track

Animate sprites frame-by-frame and with bones, then light a 2D scene with the URP 2D renderer.

Module 12: Performance & Shipping

Find and fix bottlenecks, reuse objects with pooling, and produce an optimized build ready to share.

✅ Prerequisites

This is an intermediate course. To get the most from it you should already be comfortable with:

Navigating the Unity 6 Editor — Hierarchy, Inspector, Scene and Game views, the Project panel
Creating GameObjects and adding/configuring components
Writing basic C# — variables, methods, MonoBehaviour, Update(), [SerializeField]
Rigidbodies, colliders, and simple collision handling
Building a basic UI Canvas with text and buttons
Making a build of a project

If any of those feel shaky, work through Unity Fundamentals first — this course assumes all of it.

Software

Unity 6 (6000.5 LTS) with the Universal Render Pipeline (URP)
Visual Studio or VS Code for C#
The Input System, Cinemachine, and 2D packages (installed via the Package Manager — we walk through each when it's needed)