Class Central is learner-supported. When you buy through links on our site, we may earn an affiliate commission.

Zero To Mastery

Unity Bootcamp: 3D Game Development

via Zero To Mastery

Go to class Write review

Overview

Learn Unity. Get Hired. This is the only Unity course you need to go from complete beginner (no coding experience) to coding your own 3D games and getting hired as a Game Developer this year!
  • Learn Unity from scratch (one of the top cross-platform game engines for creating professional 3D games)
  • Learn the C# programming language from scratch, including namespaces, classes, variables, functions and much more
  • Step-by-step process from creating your own game to publishing it online
  • Build a story-driven game with your own story, dialogue, music, and even cutscenes
  • How to use Unity to easily create and deploy games across multiple platforms including Windows, MacOS, iOS, Android, and many more
  • Create an RPG game with quests, rewards, potions, a combat system, weapon upgrades, and more
  • How to build games with all the bells and whistles of your favorite games
  • Use a keyboard or add your preferred controller (Nintendo Switch, XBOX, Playstation) to move your characters
  • How to launch your career as a 3D Game Developer, Unity Engineer, or Unity Developer

Syllabus

  •   Introduction
    • Unity Bootcamp: 3D Game Development
    • Exercise: Meet Your Classmates and Instructor
    • Understanding Your Video Player (notes, video speed, subtitles + more)
    • Course Resources
    • Set Your Learning Streak Goal
  •   Section 1: Getting Started
    • What Are We Creating?
    • What is Unity?
    • Installing Unity
  •   Section 2: Unity Fundamentals
    • Creating a New Project
    • Custom Layouts
    • Default Windows Overview
    • Understanding Game Objects
    • Moving Around the Scene
    • Manipulating Game Objects
    • Exercise: Creating a Robot
    • Understanding Component Composition
    • The Transform Component
    • Applying Materials
    • Exercise: Materials
    • Parent and Children Objects
    • Prefabs
    • Final Tips and Tricks
    • Let's Have Some Fun (+ Free Resources)
  •   Section 3: Designing a Scene
    • Importing Unity Package Files
    • Model File Formats
    • Model Prefabs
    • Installing Packages with the Package Manager
    • Creating a 3D Tilemap
    • Changing the Materials on a Model
    • Extracting Materials from a Model
    • Adding an Offset to a Brush
    • Exercise: Installing the Polybrush Package
    • Painting Models with a Polybrush
    • Custom Icons for Game Objects
    • Exercise: Drawing More Tilemaps
    • Exercise: Adding a Slope
    • Rotating Tiles
    • Exercise: Rotating Corner Tiles
    • Where to Find Game Assets?
    • Unlimited Updates
  •   Section 4: Getting Started with C#
    • What is C#?
    • Installing Visual Studio Code
    • Configuring Visual Studio Code
    • Creating a C# File
    • Understanding Namespaces
    • Creating a Namespace
    • What are Objects?
    • Creating Classes
    • Understanding Variables
    • Defining Variables
    • Comments
    • Constructor Methods
    • Access Modifiers
    • Inheritance Basics
    • Using Namespaces
    • Adding Classes as Components to Game Objects
    • Custom Methods
    • Parameters
    • Return Values
    • Control Flow
    • Debug Class
    • Generics
    • Attributes
    • Auto Formatting Code
    • Exploring the C# Documentation
    • Implement a New Life System
  •   Section 5: Player Movement
    • Installing the Input System Package
    • Understanding Actions and Action Maps
    • Creating Actions and Action Maps
    • Exercise: Creating a UI Action Map
    • Setting the Action Type
    • Adding Bindings
    • Composite Bindings
    • Separation of Concerns
    • Event Handlers
    • Adding a Game Manager
    • Adding the Player Input Component
    • Baking a Navigation Mesh
    • Adjusting the Agent Size
    • Adding Non-Walkable Areas
    • The Navigation Mesh Agent Component
    • Reading the Callback Context
    • Storing the Movement Vector
    • Grabbing a Component
    • Moving an Agent
    • Following the Player with a Camera
    • Framerate Independence
    • Using the Agent Speed
    • Understanding Quaternion
    • Vector Zero
    • Linear Interpolation
    • Component Catching and Organizing Code
    • Exploring the Unity Documentation
    • Course Check-In
  •   Section 6: Intermediate C#
    • Creating Instances
    • Static Modifier
    • Understanding Abstract Classes
    • Using an Abstract Class
    • Using Abstract Classes as Types
    • Base Constructor Methods
  •   Section 7: AI Movement
    • Prefab Variants
    • Requiring Components
    • Creating a Controller
    • Serializing Fields
    • Tags
    • Using Constants
    • Calculating Distance with Vectors
    • Disabling Serialization
    • Custom Gizmos
    • Moving Agents by Destination
    • Introduction to the State Pattern
    • Creating a Base State
    • Setting a Default State
    • Creating a Return State
    • Creating a Chase State
    • Transitioning Between States
    • Exercise: Creating an Attack State
    • Stopping the Agent
  •   Section 8: Patrolling with Splines
    • Creating a Patrol Enemy
    • Installing the Splines Package
    • Adding Knots
    • Adding Curved Knots
    • Closing Knots
    • Serializing Private Fields
    • Moving Enemies to the Path
    • Checking for a Missing Path
    • Creating a Patrol State
    • Verifying an Agent Reaching their Destination
    • Calculating the Next Position
    • Moving the Enemy on the Spline
    • Grabbing the Spline Length
    • Adjusting the Patrol Speed
    • Pausing the Enemy on Patrols
    • Toggling the Enemy's Patrol
    • Extracting Models
  •   Section 9: Player & Enemy Stats
    • What is a Scriptable Object?
    • Creating a Scriptable Object
    • Configuring the Character's Stats
    • Loading Enemy and Player Stats
    • Applying Stats
    • Updating the Speed
  •   Section 10: Animation
    • Updating Character Models
    • Rotating Enemies Toward the Player
    • Rotating Enemies Toward their Return Position
    • Rotating Patrolling Enemies
    • Rotating Enemy to Original Rotation
    • Disabling an Agent's Rotation
    • Adding a Treasure Chest
    • Adding a Nav Mesh Obstacle
    • Creating an Animation Clip
    • Adding Keyframes
    • Understanding the Animator Controller
    • Adding an Idle State
    • Animator Controller Parameters
    • Adding a Box Collider
    • Adding a Rigid Body
    • Listening to Key Presses
    • Updating Parameters on Animator Controllers
    • Applying an Avatar Definition
    • Preparing the Animator Controller
    • Adding a Blend Tree
    • Grabbing Components in Child Objects
    • Checking the Callback Action
    • Updating the Animator Speed
    • Smoothening the Animator Speed
    • Exercise: Using Constants for Animator Parameters
    • Looping Animations from Models
    • Adding Animation to Enemies
    • Updating the Movement Speed of Enemies
    • Custom Clamping
    • Custom Tags
    • Exercise: Imposter Syndrome
  •   Section 11: Combat
    • Trigger Parameters
    • Setting a Trigger
    • Custom Animation Events
    • Bubbling Events
    • Empty Lambda Expressions
    • Capturing Bubbled Events
    • The Event Keyword
    • Preventing the Excessive Attacks
    • Removing Event Handlers
    • Exercise: Custom Hit Bubble Event
    • Understanding Arrays
    • Box Ray Casts
    • Looping through Arrays
    • Refining the Results
    • Reducing Health Points
    • Stopping the Enemies Animation
    • Attacking the Player
    • Looking at the Player
    • Canceling the Attack
    • Adding a Defeat Animation
    • Handling the Player's Defeat
    • Exercise: Tracking a Character's Defeated State
    • Destroying Game Objects
    • Checking the Player is Alive
    • Handling the Enemy's Defeat
  •   Section 12: User Interfaces
    • Creating a Custom Scene
    • Creating a UI Document
    • Using a Visual Element
    • Adding Text
    • Unity Stylesheets
    • Exercise: Extracting Text Styles
    • Custom Fonts
    • Centering Elements
    • Adding Buttons
    • Adding an Image
    • UI Document Game Object
    • Exercise: Binding UI Actions
    • UI Base State
    • Main Menu State
    • Retrieving the Root Visual Element
    • Understanding Lists
    • Querying a List of Buttons
    • Exercise: Handling Interaction Events
    • Handling the Selection
    • UI Navigation
    • Ternary Operator
    • Toggling Classes
    • Scene Transition
    • Creating the Player Info UI
    • Loading the UI in Another Scene
    • Toggling the UI's Display
    • Observer Pattern
    • Creating an Event Manager
    • Null Conditional Operator
    • Sending Data with Events
    • Updating the Health Label
    • Healing the Player
    • Exercise: Updating the Potion Count UI
    • Adding a Canvas
    • Adding the Health Bar Image
    • Slider Component
    • Dynamically Updating the Slider
    • Adding the Health Bar to the Enemy
    • Creating a Billboard
  •   Section 13: Dialogue
    • Installing Ink
    • Writing a Story
    • Exercise: Adding More Knots
    • Adding Multiple Choice
    • Adding the NPC
    • Toggling a Dialogue Icon
    • Handling NPC Interaction
    • Loading a Story
    • Creating the Dialogue UI
    • Dialogue UI State
    • Exercise: Entering the Dialogue State
    • Type Casting
    • Displaying a Story's Text
    • Switching Action Maps
    • Continuing the Story
    • Checking Story Choices
    • Clearing Lists
    • Looping through Lists with the ForEach Method
    • Dynamically Creating Elements
    • Setting the Active Choice
    • Selecting a Choice
    • Exiting the Dialogue
    • Fixing a Few Bugs
  •   Section 14: Quests & Rewards
    • Creating a Quest Item UI
    • Preparing the Quest Item State
    • Exercise: Entering the Quest Item State
    • Using Scriptable Objects for Quest Items
    • Adding Tooltips
    • Updating the UI Label
    • Pausing Enemy Attacks
    • Storing the Quest Item
    • Displaying the Quest Item
    • Configuring the NPC's Quest Item
    • Binding External Functions
    • Passing on the NPC
    • Initiating the Quest Item Verification
    • Checking the Player's Inventory
    • Story Variables and Conditional Statements
    • Manually Diverting Stories
    • Creating a Reward Scriptable Object
    • Understanding Enums
    • Creating an Enum
    • Creating a Reward Component
    • Sending the Reward
    • Applying Rewards
    • Adding the Weapon's Model
    • Setting Active Game Objects
  •   Section 15: Scene Management
    • Creating the Dungeon Scene
    • Finishing the Dungeon Scene
    • Creating a Portal
    • Setting the Spawn Point
    • Detecting the Player with Triggers
    • Teleporting to the Next Scene
  •   Section 16: Saving
    • Adding a Portal Event
    • Understanding PlayerPrefs
    • Using PlayerPrefs
    • Checking for Saved Data
    • Retrieving Saved Data
    • Dynamically Adding a New Button
    • Loading the Correct Scene
    • Deleting PlayerPrefs
    • Warping an Agent
    • Creating Enemy IDs
    • Converting an Array to a List
    • Checking for Defeated Enemies
    • Joining Strings
    • Splitting Strings
    • Fixing the List
    • Despawning Enemies
    • Saving the Player's Quest Items
    • Checking for Quest Items
    • Stopping the Quest Item State
    • Checking the NPCs for Quest Items
    • Updating NPCs with Quest Items
  •   Section 17: Camera, Lights, Action!
    • Camera Priority
    • Adding Virtual Cameras
    • Creating a Sequence
    • Camera Dolly
    • Animating the Camera Dolly
    • Creating a Cinematic Trigger
    • Playing Sequences
    • Playable Director Events
    • Stopping Player Movement
    • Toggling Booleans
    • Adding the Enemy Boss
    • Exercise: Creating a Cutscene
    • Custom Awake Behavior
  •   Section 18: Audio
    • Audio Components
    • Finding Audio
    • Adding an Audio Clip
    • Playing an Audio Clip
    • Attack Sound Effect
    • Attack Audio Event
    • Treasure Chest Sound Effect
    • Exercise: Reward Sound Effect
    • Creating a Victor/Game Over UI
    • Displaying the Victor/Game Over UI
    • Storing Audio Clips
    • Playing Audio for Game Completion
    • Looping Audio
    • Understanding Enumerators
    • Using IEnumerator
    • Fading Out Audio
  •   Section 19: Polishing the Game
    • Adding Weapons to Enemies
    • Adding Pause States
    • Toggling Pause Statess
    • Preventing the Player from Pausing
    • Setting the Time Scale
    • Adding a Dirt Path
    • Updating our Maps
    • Baking the Navigation Mesh
    • Adding an Ocean Plane
    • Updating the Main Menu Scene
    • Rotating the Camera Around a Point
    • Skyboxes
    • Supporting Additional Input Devices
  •   Section 20: Publishing a Game
    • WebGL Builds
    • Publishing to Itch.io
  •   Where To Go From Here?
    • Thank You!
    • Review This Course!
    • Become An Alumni
    • Learning Guideline
    • LinkedIn Endorsements
    • Coding Challenges

Taught by

Luis Ramirez Jr

Reviews

Start your review of Unity Bootcamp: 3D Game Development

Go to class

Never Stop Learning.

Get personalized course recommendations, track subjects and courses with reminders, and more.

Sign up for free
Someone learning on their laptop while sitting on the floor.