Ultimate Unreal Engine & C++ Game Development

Basics to Expert with two projects | Helicopter Bot Fighter | Advanced AI Shooter Game

What you'll learn

Advanced C++ Concepts for Unreal Engine

Animations and Motion Matching

Create intelligent NPCs with AI Perception Systems for sight and hearing.

Master Object-Oriented Programming (OOP) with classes, inheritance, and polymorphism.

Understand Unreal Engine’s class hierarchy, macros like UPROPERTY, UCLASS, UFUNCTION, and the use of casting for object manipulation.

AI Systems and Behavior

Virtual functions, pointers, smart pointers, and Unreal’s memory management systems.

Learn template functions and classes to create reusable code.

Game Mechanics and Physics

Set up version control with GitHub to track code changes and access lecture-specific updates.

Build complex systems using coordinates, vectors, and rotators.

Game Development Best Practices

Set up Behavior Trees and Blackboards for dynamic decision-making.

Program AI to chase, attack, and strategically respond to player actions.

Retarget animations and work with skeletal meshes.

Design smooth transitions using Animation Blueprints and montages.

Weapon Systems

Build a complete weapon system with pickup functionality, projectile mechanics, and shooting animations.

Master line tracing by channel to detect hits and apply damage dynamically.

UI and Game Modes

Requirements

No prior knowledge of Unreal Engine or C++ is required.

A PC capable of running Unreal Engine 5 smoothly.

Description

Welcome to the ultimate Unreal Engine and C++ course, where you’ll learn everything you need to master game development—from the very basics to advanced mechanics. By the end of this course, you’ll have the knowledge and confidence to build your own games using the full power of Unreal Engine and modern C++. Not only will you create two complete games in this course, but you’ll also gain a deep understanding of the logic and reasoning behind every concept, empowering you to create anything you imagine.Course HighlightsTwo Complete Projects: Create a Helicopter Bot Shooter Game to learn the basics and an Advanced Shooter Game to master AI, animations, and combat mechanics.Cutting-Edge Tools: Explore Unreal Engine’s latest features, including Enhanced Input, Motion Matching, and advanced AI perception systems.Version Control: Learn GitHub integration to manage your projects professionally and access project files easily.Step-by-Step Guidance: Start with the fundamentals and progress to advanced topics, ensuring a thorough understanding of both C++ and Unreal Engine.Why Take This Course?This course is designed to be the most complete and beginner-friendly guide to Unreal Engine and C++ available. Starting with the fundamentals, we gradually build up to advanced techniques, ensuring you develop a strong foundation before tackling complex topics. Each concept is explained step by step, so you don’t just follow along—you truly understand how and why it works.By learning Unreal Engine and C++ together, you’ll unlock a professional-level skill set that gives you the freedom to create any type of game, whether it’s a simple platformer, an action-packed shooter, or an AI-driven open-world experience.What Will You Learn?1. Unreal Engine and C++ BasicsWe begin by introducing the Unreal Engine interface and the basics of C++ programming. You’ll set up your environment, learn to navigate Unreal’s tools, and create your first project. For those who already know the basics, you can skip ahead. However, this section lays a strong foundation, covering essential topics like:Writing simple C++ scripts to interact with Unreal Engine objects.Using Unreal Engine’s editor tools for faster and smarter game design.2. Mastering C++ for Unreal EngineThis section is the heart of the course. We’ll explore the C++ programming concepts that power Unreal Engine in great depth. Each topic is explained with real-world examples, so you’ll fully understand how these principles work in game development:Object-Oriented Programming (OOP):How Unreal Engine uses OOP to structure its framework.Understanding classes, objects, inheritance, and polymorphism.Real-world examples of inheritance in Unreal Engine, such as extending the Actor class.Virtual Functions:Why virtual functions are critical for game logic in Unreal.How polymorphism is used to override behavior in derived classes.Memory Management:Learning about pointers and why they’re essential for Unreal Engine development.Understanding smart pointers (unique, shared, and weak) for safer memory management.Unreal Engine’s built-in alternatives to pointers, like TObjectPtr and TSubclassOf.Template Functions and Classes:Writing reusable and efficient code for common tasks.Examples of template functions in Unreal Engine, such as TArray and FVector.Casting and Unreal’s Cast System:The role of static and dynamic casting in C++.Unreal Engine’s Cast<T> function and how it simplifies working with objects.3. Understanding Game Coordinates and MathWe’ll break down the coordinate system that defines every object’s position in Unreal Engine. You’ll also master vectors and rotators, which are crucial for movement, rotations, and physics-based interactions. Key topics include:Manipulating vectors for precise movement.Using rotators for smooth character rotation and aiming.4. Unreal Engine-Specific ConceptsThis section dives deep into how Unreal Engine works under the hood and how to integrate your C++ code into its framework. You’ll learn:Unreal Engine’s class hierarchy and how to extend its classes.Essential macros like UPROPERTY, UCLASS, and UFUNCTION.How macros communicate with the editor for property visibility, replication, and more.Creating custom Actor components to extend functionality.5. First Game Project: Helicopter Bot ShooterIn this project, you’ll create a fully functional helicopter shooter game with NPC bot fighters. You’ll learn about:Pawn Classes:Controlling the player’s helicopter using the Pawn class.Setting up input using Unreal Engine’s new Enhanced Input system.Camera Systems:Adding a camera and spring arm for better gameplay visualization.NPC Bots:Spawning enemy bots and programming simple AI behaviors.Completing a playable game, combining movement, shooting, and AI bot interactions.6. Version Control with GitHubProperly managing your game project is vital. In this section, you’ll learn:Setting up GitHub for version control.Submitting commits to track your code changes.Providing access to lecture-specific code snapshots, so you can follow along and see progress at each step.7. Second Game Project: Advanced Shooter with AIThis advanced project takes your skills to the next level by focusing on modern gameplay systems:Character Class and Animation:Creating a custom character class with animations.Retargeting animations and using Unreal Engine’s Motion Matching system for realistic animation blending.Physics and Collision Systems:Building realistic interactions using Unreal’s physics engine.Setting up collision rules for weapons, projectiles, and environmental objects.Weapon Systems:Designing a weapon class with pickup functionality.Adding shooting mechanics with line tracing by channel.Implementing a health and damage system for players and AI.AI Development:Using the AI Perception System to give bots hearing and sight.Setting up Behavior Trees and Blackboards for dynamic AI behaviors.Programming bots to chase, attack, and respond to player actions.8. UI and Game ModeTo make your games feel complete, you’ll learn to create simple yet functional user interfaces and game modes:Designing a HUD for health and weapon.Updating the UI dynamically from C++.Configuring game rules with custom Game Modes.9. Finalizing Your GameIn the final section, you’ll polish and final your game:Setting up a new map and configuring game settings.Preparing your game for sharing or publishing.What Makes This Course Unique?This isn’t just a course where you follow along. Each topic is explained in depth, so you understand not just how but why things work. By the end, you won’t just know how to create the two projects—you’ll have the freedom and confidence to build your own games from scratch, using the full power of Unreal Engine and C++.Join now, and let’s start creating something incredible!

Overview

Section 1: Introduction

Lecture 1 Introduction

Section 2: C++

Lecture 2 First Program in C++

Lecture 3 Statements in C++

Lecture 4 Names and Keywords

Lecture 5 Building C++ Program

Lecture 6 Errors and Warnings

Lecture 7 Data Types

Lecture 8 Variables

Lecture 9 Integers

Lecture 10 const Keyword

Lecture 11 Operations on Integers

Lecture 12 Increment and Decrement Operators

Lecture 13 Floating Point

Lecture 14 Type Conversion

Lecture 15 Characters

Lecture 16 Strings

Lecture 17 auto Keyword

Lecture 18 Variable Lifetime

Lecture 19 Operators

Lecture 20 Arithmetic Operators

Lecture 21 Assignment Operators

Lecture 22 Relational Operators

Lecture 23 Logical Operators

Lecture 24 Conditional Operator

Lecture 25 Boolean

Lecture 26 if - else

Lecture 27 if-else Example

Lecture 28 else if

Lecture 29 Nested if

Lecture 30 Switch

Lecture 31 Loops

Lecture 32 while Loop

Lecture 33 do…while Loop

Lecture 34 for Loop

Lecture 35 Range based for Loop

Lecture 36 Arrays

Lecture 37 Array Elements

Lecture 38 Cpp strings

Lecture 39 Functions

Lecture 40 Calling Functions

Lecture 41 Parameters and return

Lecture 42 Default Arguments

Lecture 43 Arrays to Functions

Lecture 44 Static Variables

Lecture 45 Function Overloading

Lecture 46 Recursion

Lecture 47 How do function calls work

Lecture 48 Inline Functions

Lecture 49 Pointers

Lecture 50 Dereferencing Pointers

Lecture 51 Array of Pointers and pointer to array

Lecture 52 Constant and Pointers

Lecture 53 Pointer Arithmetic

Lecture 54 Dynamic Memory Allocation

Lecture 55 Hazards of Dynamic Memory Allocation

Lecture 56 Hazards of Dynamic Memory Allocation - Example

Lecture 57 Smart Pointers

Lecture 58 Unique Pointer

Lecture 59 Shared Pointer

Lecture 60 Reference

Lecture 61 Returning a pointer from a function

Lecture 62 Passing by Reference

Lecture 63 Returning Reference from a Function

Lecture 64 Input and Output Parameters

Lecture 65 Enumerations

Lecture 66 Enumerations (Examples)

Lecture 67 OOP

Lecture 68 Accessing Class Members

Lecture 69 Struct

Lecture 70 Member Methods

Lecture 71 Constructors and Destructors

Lecture 72 Default Constructor

Lecture 73 friend Class

Lecture 74 Setters and Getters

Lecture 75 Namespace

Lecture 76 Nested Namespace

Lecture 77 Inheritance

Lecture 78 is a' test

Lecture 79 protected class members

Lecture 80 Constructors and Destructors

Lecture 81 Override class Methods

Lecture 82 Polymorphism

Lecture 83 virtual Functions

Lecture 84 VTables

Lecture 85 Default Arguments with virtual functions

Lecture 86 static_cast

Lecture 87 dynamic_cast

Section 3: Concepts

Lecture 88 Coordinates

Lecture 89 Vectors

Lecture 90 Operations on Vector

Lecture 91 Rotators

Section 4: C++ in Unreal Engine

Lecture 92 Setting Up Visual Studio

Lecture 93 Unreal Engine Class Hierarchy

Lecture 94 Reflection and garbage collection

Lecture 95 Actor Class

Lecture 96 Creating Blueprint

Lecture 97 UE_LOG Compile and Hot Reload

Lecture 98 On Screen Message

Lecture 99 Formatting FString

Lecture 100 Actor Location and Rotation

Lecture 101 AddActorWorldOffset and DeltaTime

Lecture 102 UPROPERTY

Lecture 103 Exposing Variables to Blueprint

Lecture 104 UFUNCTION

Lecture 105 Template Functions

Lecture 106 Components

Section 5: Helicopter Fighter Game

Lecture 107 Pawn Class

Lecture 108 City Map

Lecture 109 Helicopter Mesh

Lecture 110 Camera And Spring Arm Components

Lecture 111 Enhanced Input

Lecture 112 Subsystem

Lecture 113 Input Action

Lecture 114 Helicopter Movement

Lecture 115 Controller Rotations

Lecture 116 Bot Class

Lecture 117 Target Helicopter

Lecture 118 Find Look At Rotation

Lecture 119 RInterpTo

Lecture 120 Projectile Movement

Lecture 121 Bullet Material

Lecture 122 Spawning Bullet

Lecture 123 Set Timer

Lecture 124 Sound and Particle Effects

Lecture 125 Collision Components

Lecture 126 On Hit Component

Lecture 127 Other Actor

Lecture 128 Destroy Helicopter

Lecture 129 Stop Firing

Lecture 130 Helicopter Weapon Components

Lecture 131 Helicopter Fire()

Lecture 132 Helicopter Shoot Input

Lecture 133 Destroy Bot

Lecture 134 Map Changes

Lecture 135 Final Result

Section 6: GitHub Version Control

Lecture 136 GitHub Repository

Lecture 137 Commit

Section 7: Character Class

Lecture 138 Importing Assets

Lecture 139 Retargeting Animations

Lecture 140 The Character Class

Lecture 141 Setup Enhanced Input

Lecture 142 Character Movement

Lecture 143 Camera and Spring Arm

Lecture 144 Look Around

Lecture 145 Animation Blueprint

Lecture 146 Motion Matching

Lecture 147 Jump

Section 8: Physics and Collision

Lecture 148 Physics and Collision

Lecture 149 Collision Presets

Lecture 150 Collision Components

Section 9: Weapon

Lecture 151 Weapon Assets

Beginners: Start with no prior experience and build your skills from the ground up.,Intermediate Developers: Extend your knowledge of Unreal Engine and C++ by diving into advanced concepts.,Learn to create professional-grade games with AI, physics, and animations.