Top 8 Recommended Unreal Engine Self-Study Materials! [November 2024]

This is the Ultimate Blueprint course for Unreal Engine 5.

In this course, you will start with absolutely no experience in game development whatsoever. All of the important terms and concepts in game development will be introduced to you and explained carefully and in detail. By the end, you will have four small game projects of different genres, ranging from 2D to 3D, and you'll understand the underlying principles needed to make any creation you can imagine.

The course starts you off as a complete beginner, but experienced developers will also benefit from this course, as many best practices and advanced features are covered throughout.

The course begins at the beginning - downloading the Epic Games Launcher, where we will install Unreal Engine 5, as well as gain access to the Epic Games Marketplace where we can get tons of free, high-quality assets for our games. After familiarizing ourselves with the Unreal Engine editor, learning about asset types and how to import asset files, we get some practice manipulating objects in the level and building simple game environments with free asset packs.

We then get started learning the basic structure of the Blueprint visual scripting system, as well as cover the fundamental math skills every game developer needs to understand. We get practice visualizing vectors in the engine with the various debug drawing Blueprint nodes.

With the original assets created specifically for this course, we then create our first simple game, Bad Bot - a drone flying shooter. We cover the fundamentals of Unreal Engine's class hierarchy, learning about the various game classes that come together to form a basic game - including the Actor, the Pawn, the Game Mode, and the Controller. We learn how to bind inputs from keyboard, mouse, and console controller using Unreal Engine's Enhanced Input System. This project covers spawning enemy bots, firing projectiles, and adding sound and visual effects such as impacts and explosions, before finishing the level with a boss fight.

We then dive deep into Unreal Engine's collision framework, with a section dedicated to the collision system in Unreal Engine. We learn how Unreal Engine handles collision, including knowledge of:

• The physics system versus the query system

• Collision Complexity and how meshes can have both simple and complex collision and how to configure these

• How the method of movement determines the type of interactions objects will have with each other

• Sweeping collisions versus physics collisions

• Collision Enabled, Collision Object Types, and Collision Responses, and how these work together

• Custom collision channels, custom collision profiles, and optimization for performance

By the end of this chapter, Unreal Engine's collision framework will be completely demystified and you'll easily be able to configure the collision settings correctly so that your game object interact as intended, optimized for performance, and without invisible collision interactions affecting the game's frame rate.

With our newly-acquired collision skillset, we start the second game project of the course, Jetpack Journey - a third-person platformer with Kix, an original character created, rigged, and animated for this course. Kix has a jetpack, allowing us to step up our complexity, going from the Pawn class to the Character class. We learn about the Character Movement Component, and how to change movement modes from walking to flying. We implement a fully-functional jetpack with a blendspace, allowing for smooth blending of animations while flying. This project involves creating precious resources in the form of jet fuel, allowing us to implement pickups to refuel, a progress bar for the fuel percent, and moving platforms that force the player to use the flying capability. We learn about some very important concepts in this section, including:

• Movement modes, and switching to flying mode

• Single and two-dimensional Blendspaces to blend between animation poses

• Binding inputs in the Player Controller versus the Character class

• Keeping Blueprint nodes clean and readable

• Managing class dependencies and coding best practices - we're using Blueprints, but we should still follow best practice!

• Skeletal Mesh Sockets, utilized for jetpack thruster effects

• Enforcing precious resources in the form of jet fuel, with jet fuel pickups to refill fuel

• Use of UMG (Unreal Motion Graphics) to create UI including a progress bar to display fuel percent

• The impact of Casting on runtime performance and memory via the creation of hard references

• Analyzing class memory size via the size map, and dependencies via the reference viewer

• Reducing file size with texture compression

• Lazily loading of assets at runtime and how to load assets asynchronously, using soft object and class references

• Lighting and Post Processing

This section covers many important aspects of game development that even experienced developers aren't aware of. You're verging on intermediate-to-advanced territory with some of these!

The next game project introduces Unreal Engine's 2D capabilities, as we enable the built-in Paper2D plugin for 2D games. We also download the now-free PaperZD, a very important 2D plugin allowing us to use important 2D features for our games. This section's game project is a 2D dungeon-crawling side-scroller with Red Hood, a hooded 2D figure who ventures through a dark dungeon, battling skeleton minions via melee combat. We cover some valuable ground in this section, including:

• Where to get free 2D assets, including animated characters, props, UI and environments

• Creation of sprites, flipbooks, tile sets and tile maps

• Important settings for a 2D Unreal Engine game project

• 2D level creation

• Enemy AI with the Behavior Tree and Blackboard

• Combat and combo attacks

• Use and creation of the compound data types such as enums and structures

• Floating damage numbers

• Implementing melee combat

By this point, you will have the skills necessary to create your own game projects, but we're not quite done yet. We wrap up the course with a final section on Unreal Engine's Chaos Vehicles! Chaos Vehicles are Unreal's physics-based vehicle system. We use original assets created specifically for this course, importing a sci-fi car and wheels into the engine. We use the engine's built-in rigging tools to create a skeleton and skin it to the mesh, before creating a fully-functional chaos vehicle. We end by implementing enter/leave functionality for the car, by migrating the vehicle into our Jetpack Journey project so Kix can enter and leave the vehicle. We learn:

• Creation of Skeletal Meshes from Static Meshes

• Rigging and skinning, creating a vehicle skeleton and physics asset

• Creation of a fully-functional chaos vehicle with keyboard/mouse and console controller input (using Enhanced Input)

• Coverage of Chaos Vehicle settings including torque/rpms, friction, front/rear/all-wheel drive, front/rear wheel steering, and more

• Migrating the vehicle into our Jetpack project

• Changing possession of Pawns/Characters to enter and exit the vehicle.

By the end of this course, you will have gone from absolute beginner to having intermediate/advanced skills. You will understand the principles necessary to create game projects on your own. You will have hands-on practice, as well as theoretical knowledge underlying every tool and concept used throughout this course.

You will also have access to our Druid Mechanics Discord Community, a community of over 23,000 students of all skill levels, all interacting, conversing, and helping each other throughout their game development journeys.

After this course, you will fully understand Unreal Engine's architecture and class hierarchy. If your aim is to develop your own games, or even to further your career or learning journey, or move on to tackle Unreal's C++ system, this course will prepare you and equip you with the skills needed to do so.

You will gain lifetime access to the course for a single, one-time fee. You will have access to all updates and patches made to the videos.

If you're ready to learn how to make your own games, this course is ready for you.

See you soon!

1. Introduction
2. Introduction to Unreal Engine
3. Assets for the Course
4. Your First Challenge
5. Installing the Engine
6. Our First Project
7. Editor Layout
8. Play In Editor
9. Manipulating Objects
10. Perspective
11. File Types
12. Mesh Scale
13. Materials
14. Drone Material
15. Assets now in FAB
16. Marketplace Assets
17. Migrating Assets
18. Section 1 Quiz
19. The Blueprint Visual Scripting System
20. What is Blueprint
21. The Level Blueprint
22. Creating a Blueprint Class
23. Components
24. Append String
25. Coordinates
26. Debug Shapes
27. Local vs Global Space
28. Section 2 Quiz
29. Vectors and Rotators
30. Vectors
31. Vector Examples
32. Vector Examples Practice
33. Vector Operations
34. Vector Operations Examples
35. Vector Operations Practice
36. Vector Magnitude
37. Vector Magnitude Examples
38. Vector Magnitude Practice
39. Booleans and Branches
40. Vector Normalization
41. Vector Normalization Practice
42. Delta Seconds
43. Rotators
44. Rotators Practice
45. Section 3 Quiz
46. Bad Bot - A Drone Flying Shooter Game
47. Multiple Materials Per Mesh
48. Geting a Reference to the Pawn
49. Interpolation
50. Static Mesh Sockets
51. Blaster Beam Mesh
52. Spawning Actors
53. Projectile Movement
54. Blueprint Functions
55. Niagara Systems
56. Spawning Effects
57. Meta Sounds
58. Timers
59. Hit Events
60. Expose on Spawn
61. Floating Spheres
62. Rotating the Spheres
63. Timelines with Float Curves
64. Timelines with Vector Curves
65. Sphere Spawner
66. Overlap Events
67. Game Mode
68. Bad Bot Level
69. Section 4 Quiz
70. Pawns and Enhanced Input
71. The Pawn Class
72. Creating a Custom Pawn Class
73. Adding Components to the Bot Pawn
74. The Enhanced Input System
75. Firing the Rifle
76. Mouse Movement
77. Floating Pawn Movement Component
78. Camera Lag
79. Section 5 Quiz
80. Collision Essentials
81. Unreal Engine's Collision Framework
82. Collision Complexity
83. Queries
84. Sweeeping Collisions
85. Set Actor Location with Sweeping
86. Collisions with Physics
87. Collision with Movement Components
88. Collision Callbacks
89. Custom Collision Presets
90. Custom Collision Object Types
91. Section 6 Quiz
92. Bad Bot Wrap-Up and Boss Fight
93. Material Instances
94. Blueprint Interfaces
95. Widget Blueprints
96. Line Trace for Aiming
97. Level Assets
98. Bot Spawn Volume
99. Spawning Bots
100. Boss Bot
101. Boss Challenge
102. Boss Challenge Pt 2
103. Section 7 Quiz
104. Jetpack Journey - a 3D Platformer with a Jetpack
105. The Character Class
106. Creating the Kix Character
107. Kix Game Mode
108. Camera and SpringArm
109. Look Input Action
110. Kix Player Controller
111. WASD Movement
112. Clean Nodes
113. Jumping
114. Console Controllers
115. Animations
116. Blendspaces
117. State Machines
118. Movement Parameters
119. State Alias
120. Skeletal Mesh Sockets
121. Thruster Effect Components
122. Activating Thrusters
123. Thruster Sounds
124. Flying Mode
125. Thruster Movement Input
126. Flying Blendspace
127. Blend Poses vs State Machines
128. Sound Notifies
129. Jet Fuel
130. Enforcing Jet Fuel
131. Fuel Assets
132. Jet Fuel Actor
133. Refilling Jet Fuel
134. Juicing it Up
135. Widget Blueprints
136. Fuel Bar
137. Class Dependencies
138. Updating the Fuel Bar
139. Casting and Memory
140. Texture Compression
141. Soft References
142. Section 8 Quiz
143. Platformer Mechanics and Advanced Skills
144. Platforms
145. Pressure Plate
146. Moving the Plate
147. Interact Interface
148. Floating Platform
149. Ping Pong Platform
150. Placing Items
151. Packed Level Actors
152. Win and Lose
153. End Game Menu
154. Menu Functionality
155. Event Dispatchers
156. Data Types
157. The Construction Script
158. Section 9 Quiz
159. A 2D Dungeon Crawler - Red Hood
160. Free 2D Assets
161. Project Creation
162. Sprites
163. Flipbooks
164. Paper Character
165. Camera Settings
166. Input
167. PaperZD
168. Locomotion
169. Transitional Animations
170. Sound Notifies
171. Jump Sounds
172. State Events
173. Tilesets
174. Tileset Layers
175. Sort Priority
176. 2D Level
177. Level and Adjustments
178. Enemy Class
179. Behavior Tree
180. Behavior Tree Tasks
181. Decorators
182. Patrol Box Overlaps
183. Services
184. Custom Decorators
185. Attack Task
186. Skeleton Sounds
187. Box Trace
188. Anim Notifies
189. Trace for Objects
190. Hit React
191. Disable Movement
192. Hit React Effects
193. Damage and Health
194. Player Health Bar
195. Updating the Health Bar
196. Damage Numbers
197. Attack Input Action
198. Throttling Attacks
199. Attack Combo
200. Attack Count

Learn Unreal Engine 5 C++ Programming by Creating an Action-RPG Style Open World Game!

This course will take you from beginner to hero as we create everything in this course project from scratch. Learn Unreal Engine 5's new features from Open World maps, Quixel Bridge megascans for ultra-realistic environments, landscape sculpting and painting, dungeons, free-roaming creatures and humanoids with various weapons, breakable objects that spawn treasure, and more!

Slay your way through your open world level, hacking and slashing creatures, breaking pots and collecting treasure and souls, and try to keep your health and stamina high!

We will implement enemy behavior that can be reused for various creature types, including gruntlings, raptors, insects, and golems. Code your character to be able to pick up and equip better and better weapons as she slays stronger and stronger monsters and collects loot.

We will cover new Unreal Engine 5 features such as Motion Warping, Meta Sounds, Linked Anim Graphs, UE5's new retargeting system with IK Rigs and IK Retargeters, Leg IK with Control Rigs, visual effect creation in Niagara, and more!

We'll start with a completely empty level and add everything from sky and atmosphere, nature, trees and plants, and we'll even import an entire dungeon level with the use of UE5's new Packed Level Instance feature.

We will cover vectors and game development mathematics in a full math section to prepare you for gameplay programming before diving in and creating our first C++ class.

We will then learn Unreal Engine's class hierarchy, creating a basic Actor, learning about trigonometry as we use the sine function to give our items floating behavior.

We then create a Bird using the Pawn class so we can fly around our level and get a literal bird's-eye view.

We then create our Character class, using Echo from the Valley of the Ancient Epic-released free project, a beautiful and lifelike humanoid with cloth physics on her scarf and garments.

We implement weapon equipping and combat. We learn how to calculate directional hit reactions, using root motion animations to make our enemies stumble in the correct direction based on the direction of impact.

We give our enemies patrolling behavior, then chasing and attacking behavior. We make our enemies smarter with the use of UE5's new Motion Warping system, warping our enemy's location and rotation to make it hit the target more frequently, and making it harder to move out of harm's way.

We then give Echo a fighting chance, by implementing a dodge ability, similar to Dark Souls and Elden Ring. She can dodge out of the way while the enemy swings fervently, making them miss so we can move in to counter-attack.

We make breakable pots and vases using the Chaos destruction system, and these breakables spawn treasure when we break them, allowing us to collect loot and increment our gold count in the HUD.

We create a beautiful Soul effect in Niagara, and make enemies spawn souls upon death so we can gain experience points.

We learn how to make enemies stronger with an Attribute component, giving them varying levels of health and damage, and soul spawn counts.

We use UE5's new Animation Blueprint Templates to reuse all of our enemy code to create different types of enemies, from humanoids that wield weapons to creatures that bite, sting, and smash.

Get your RPG project started with this amazing course, which is the product of nearly a decade of professional Unreal Engine experience and teaching.

This course is in a whole new universe than the original UE4 version I created four years ago! Benefit from years of learning, teaching, and implementing Unreal's newly evolved system with its cutting-edge game creation capabilities!

This is my most well-taught course yet, and by far the most beautiful game project of all my courses on Udemy thus far.

Join me and let's have a ton of fun creating the start of an action RPG hack-and-slash Open World game in Unreal Engine 5!

1. Getting Started
2. Introduction
3. How to Get Help
4. Installing Unreal Engine 5
5. The Level Editor Viewport
6. View Modes
7. Object Manipulation
8. Panels
9. Section 1 Challenge
10. Realistic Landscapes
11. Assets now under FAB
12. Quixel Bridge
13. Open World
14. Lighting and Atmosphere
15. Landscape
16. 11 - Landscape Material
17. Landscape Painting
18. Tiling in Landscape Textures
19. Foliage Painting
20. More Foliage Painting
21. Post Process Volume
22. Forest Polish Up
23. If You Get This Popup While Migrating...
24. Packed Level Actors
25. Mountains
26. Level Instances
27. Section 2 Challenge
28. Vectors, Rotators, and Trigonometry
29. Coordinates
30. Vectors
31. Vector Examples
32. Vector Operations
33. Vector Operations Examples
34. Vector Magnitude
35. Vector Magnitude Examples
36. Vector Normalization
37. Rotators
38. Section 3 Challenge
39. C++ in Unreal Engine
40. Integrated Development Environment (IDE)
41. Setting up Visual Studio
42. C++ Refresher
43. Reflection and Garbage Collection
44. Section 4 Challenge
45. The Actor Class
46. Actor Creation
47. Blueprint Creation
48. Onscreen Debug Messages
49. Formatting Strings
50. Drawing Debug Spheres
51. Drawing Debug Lines
52. Drawing Debug Points
53. Custom Header Files
54. Section 5 Challenge
55. Moving Objects With Code
56. SetActorLocation
57. SetActorRotation
58. Actor World Offset
59. Trig Functions
60. The Sine Function
61. Exposing Variables to Blueprint
62. Visible But Not Editable
63. Exposing Variables to the Event Graph
64. Exposing Functions to Blueprint
65. Template Functions
66. Components
67. Components in C++
68. Section 6 Challenge
69. The Pawn Class
70. The Pawn Class
71. Capsule Component
72. Forward Declaration
73. Skeletal Mesh Components
74. Enhanced Input
75. Binding Inputs
76. Enhanced Input for Movement
77. Adding Movement Input
78. Camera and Spring Arm
79. Enhanced Input for Controller Input
80. Adding Controller Input
81. Setting the Default Pawn
82. Section 7 Challenge
83. The Character Class
84. The Character Class
85. Enhanced Input for the Character
86. Character Inputs
87. Character Camera and SpringArm
88. The Rotation Matrix
89. Controller Directions
90. Hair and Eyebrows
91. Custom Hair Color
92. Section 8 Challenge
93. The Animation Blueprint
94. The Animation Blueprint
95. The Anim Instance
96. Jumping
97. Jump Animations
98. Inverse Kinematics
99. Section 9 Challenge
100. Collision and Overlaps
101. Collision Presets
102. Overlap Events
103. Delegates
104. On Component Begin Overlap
105. On Component End Overlap
106. Section 10 Challenge
107. The Weapon Class
108. The Weapon Class
109. Sockets
110. Downloading Animations
111. Retargeting is now Easier in 5.4!
112. IK Rig
113. IK Retargeter
114. Attaching the Sword
115. Picking Up Items
116. Enum for Character State
117. Switching Animation Poses
118. Equipped Animations
119. Multiple Animation Blueprints
120. Section 11 Challenge
121. Attacking
122. Animation Montages
123. Playing Montages from C++
124. Attacking State
125. Resetting the Action State
126. Item State
127. Sound Notifies and Meta Sounds
128. Meta Sounds for Footsteps
129. Fixing Foot Placement
130. Putting the Sword Away
131. Playing Arm and Disarm Animations
132. Attaching the Sword to the Back
133. Equip and Unequip Sounds
134. Editing Animations
135. Section 12 Challenge: Option A
136. Section 12 Challenge: Option B
137. Weapon Mechanics
138. Collision Box
139. Tracing
140. Box Trace in C++
141. Dynamic Arrays
142. Disabling Weapon Box Collision
143. Unreal Interfaces
144. Enemies
145. Notes on the Blender Addon
146. Root Motion Animations
147. Implementing Interfaces
148. Hit React Montage
149. Playing the Hit React Montage
150. Dot Product
151. Cross Product
152. Directional Hit Reactions
153. One Hit Per Swing
154. Hit Sounds
155. Hit Particles
156. Weapon Trails
157. Section 13 Challenge
158. Breakable Actors
159. Destructible Meshes
160. Field System Actors
161. Creating Fields with Weapons
162. Breakable Actor
163. Blueprint Native Event
164. Breaking Sounds
165. Section 14 Challenge
166. Treasure
167. Treasure
168. Spawning Actors
169. Spawning Actors from C++
170. Different Types of Treasure
171. Different Types of Breakables
172. Niagara Effects
173. Niagara Components
174. Section 15 Challenge
175. Combat
176. Actor Components
177. Widget Components
178. User Widget Class
179. Setting the Health Percent
180. Damage
181. Custom Health Bars
182. Enemy Death Animations
183. Enemy Death
184. Death Poses
185. Polishing Enemy Death
186. Section 16 Challenge
187. Enemy Behavior
188. Making Enemies Move
189. Enemy Movement Anims
190. Blendspaces
191. Patrol Targets
192. Selecting Patrol Targets
193. Patrol Wait Time
194. Pawn Sensing Component
195. Enemy States
196. Enemies Losing Interest
197. Attack Radius
198. Agro When Hit
199. Weapon Alterations
200. Section 17 Challenge

This is the most comprehensive Unreal Engine course available. If you want to learn how to architect a fully-functional RPG game, this course will give you the ability to do so with an expandable code base, architected with AAA quality code. If you've ever wondered where to draw the line between C++ and Blueprints, this is the course for you. If you've ever wanted to create an RPG complete with a stats system, abilities, leveling up, spells, attributes, menus, all while keeping your code base clean and following best practices, this is the course for you. If you want to step up your Unreal Engine development capabilities and better understand the inner workings of the engine, this course is for you. If you have plans to make your own serious game with interconnecting systems, involving attributes, abilities, level ups, enemies and AI, and coded for multiplayer, this is the course for you!

In this course, we will create a top-down RPG style game, filled with systems architected using Unreal Engine's built-in Gameplay Ability System (GAS). This is where you will learn how to architect a shipped game, and code it expertly so it can be easily expanded, upgraded, and maintained. We follow SOLID coding principles, and balance the Blueprint/C++ ratio in a way that AAA shipped games do, such as Fortnite. My experience with AAA shipped game code, as well as consultations with industry veteran developers has allowed me to reveal to you the way a real shipped game's code base looks like. If you've ever wondered how much of a game can be kept in Blueprint versus C++, look no further. This course is the answer.

NOTE: This course involves programming in C++, which involves the use of an Integrated Development Environment (IDE) such as Visual Studio, Rider, or VSCode. The IDE used in this course by me will be Rider, but this IDE is not a requirement for students to follow the course. You can use any IDE of your choice.

The assets in this game project were made specifically for this course, and will be provided in an asset pack. This includes:

• Characters, including Aura, the main character, as well as enemy characters including Goblin Warriors, Goblin Rangers, a Goblin Shaman, Red and Black Demons, the Ghoul, and a Shroom.

• A modular dungeon pack that can be pieced together to make basic dungeons

• A waypoint shrine and obelisks

• Particle Niagara System Effects, including explosions, level up effects, slingshot rocks, hit impacts, electricity beams, fireballs, fire bolts, flames, stars for stun effects, and more!

• Sound effects for enemies, footsteps, spells, and more!

• Textures for the HUD, including high-quality buttons, frames, dynamically-animated spell globes, progress bars, XP bar, and more!

• Full animation sets for Aura and all enemies

• Much more!

In this course, we will be covering the following topics:

• Setting up a Top-Down Project from scratch

• Enemy and item selection with outline effects

• Proper use of OOP and inheritance to create a character class hierarchy

• Intro to the Gameplay Ability System and the core classes that comprise it

• Custom Gameplay Ability System Components and Attribute Sets, and how to replicate Attributes

• All important settings for all GAS classes and components

• How to use Attributes for player stats, including Primary Attributes:

  • Strength (increases physical damage)

  • Intelligence (increases magical damage)

  • Resilience (increases Armor and Armor Penetration)

  • Vigor (increases Max Health)

• Secondary Attributes, based off of primary attributes and other custom variables:

  • Armor (reduces damage taken, improves Block Chance)

  • Armor Penetration (ignores percentage of enemy Armor, increases Critical Hit Chance)

  • Block Chance (change to cut incoming damage in half)

  • Critical Hit Chance (chance to double damage plus critical hit bonus)

  • Critical Hit Damage (bonus damage added when a critical hit is scored)

  • Critical Hit Resistance (reduces critical hit chance of attacking enemies)

  • Health Regeneration (amount of Health restored every 1 second)

  • Mana Regeneration (amount of Mana restored every 1 second)

  • Max Health (maximum amount of Health obtainable)

  • Max Mana (maximum amount of Mana obtainable)

• Vital Attributes - things like Health and Mana, which are dependent on all the other attributes

• Gameplay Effects - classes in the GAS system used to apply changes to attributes

• Gameplay Tags - an essential part of GAS, which allows us to identify qualities, attributes, abilities, character classes, and any other thing we can imagine

• Game UI - how to handle complex UI in an RPG game efficiently, in an organized, modular, and scalable manner. We cover different UI paradigms, from MVC (Model View Controller) and MVVM (Model View ViewModel, using Unreal Engine's new ViewModel feature)

• Full Attribute and Spell Menus, with upgrade abilities, spell trees, locked spell levels, spell upgrades by ability level, and more

• Attributes - how to use Gameplay Attributes to represent player stats, and incorporate them into the gameplay mechanics by creating an Effect Application pipeline, allowing for calculations and results caused by phenomena in the game, such as combat damage

• Gameplay Abilities - the heart of GAS. We create all manner of types of gameplay abilities to handle the casting of spells, handling important capabilities of the player character and enemy AI, and how to configure different abilities to suit your needs.

• Different RPG Classes - we implement different character RPG classes including the Ranger, Warrior, and Elementalist, and do so in an easily-scalable manner so you can have any number of character class types in your game

• Damage and Combat - we implement a full RPG style combat system with different damage types, damage resistances, and debuffs corresponding to damage types, and encode these calculations into our damage pipeline. All attributes, damage types, resistances and debuffs are functional in this game.

• All combat mechanics are displayed in some form of visual feedback to the player. This includes floating text for damage, changing color based on custom criteria, floating text to inform of critical hits, blocked hits, and critical blocked hits. We also implement knockback and stun mechanics in response to lightning damage, incapacitating the character/enemy, as well as fire debuffs, where characters are set ablaze and take fire damage while burning.

• Enemy AI - We implement the enemy behavior using Unreal Engine Behavior Trees and the Environment Query system (EQS) to provide customized behavior for the Ranged, Warrior, and Elementalist enemy types.

• Enemies can cast spells and summon AI minions

• Fading geometry when it gets in the way of the camera for a top-down game

• Ability Cost and Cooldown (spells spend Attribute resources - in this game, spells cost Mana)

• Fully functional HUD with Equipped Spells, displaying spell cooldown timers, and experience (XP)

• The ability to assign Abilities to different inputs in the spell menu (assign FireBolt to the 1 key and Electrocute to the Left Mouse Button, swap them back, etc.)

• Experience and Level-Up System - We craft an experience system, awarding XP for eliminating enemies, and leveling up when reaching XP thresholds for various abilities. XP and Level are displayed in the HUD, and Level Up messages and effects are as well. Leveling up is associated with gaining Attribute Points and Spell Points, which can be used to upgrade Attributes and Spell abilities in the Attribute and Spell Menus respectively, as well as topping off Health and Mana upon Leveling Up. (Basically, you will see enough examples of how to use this system that you'll be able to expand it with any functionality you want for your own games)

• Passive Spells - Spells that you can equip which remain active while they are equipped.

• A variety of Offensive Spells, showcasing different examples and features of GAS, including FireBolt, Electrocute, Arcane Shards, and FireBlast.

• Saving Progress and Level Transitions

• Intermediate/Advanced Unreal Engine topics, including custom Async Tasks, Ability Tasks, Blueprint Function Libraries, Asset Managers, Singletons (and why these are only good for a VERY select few cases), custom Gameplay Effect Contexts, Net Serialization, Struct Ops Type Traits, C++ Lambdas, game mechanics algorithms, and oh, so much more.

• How to choose which functionality should go into C++ versus Blueprint - This is one of the most valuable lessons, and is taught all throughout the course. Students often ask me "which functionality should go in C++ versus in Blueprint?" This course is my answer. This is a serious-scale project foundation with over 100 hours of video, and no filler. The project is architected with approximately 50% Blueprints and 50% C++. I show you which functionality should be on the C++ side, which functionality is more appropriate for Blueprints, and why.

• SOLID Coding Principles and code architecture - We keep our code base clean in this project. Another question I often get is "Is this best coding practice?" This course is my answer to this question. This is an example of code you would see in a AAA game, shipped to millions of players. Maintaining clean and modular code is essential to a serious game project that needs to be scalable, expandable, modular, maintainable, testable, performant, and efficient. This course will show you how.

This is not a beginner course. I expect you to already understand the C++ programming language and have at least created one Unreal Engine C++ project.

This course is my best course yet, and I'm very proud to bring you the Unreal Engine 5 - Gameplay Ability System - Top Down RPG course, the result of nearly a year of painstaking development, research, consultation with professionals, and asset creation. After taking this course, you will understand Unreal Engine far better than the average developer, and you'll be empowered to create your own well-architected projects, large and small, and you'll bring value to your team, your company, your solo venture, and anyone/anything else you grace with your skillset.

Join the course, and invest in the biggest leap of your game development career.

Stephen Ulibarri, founder of the Druid Mechanics Game Developer Community

This course project is created in Unreal Engine version 5.2. Updates are periodically added to ensure compatibility with newer engine versions.

1. Introduction
2. Introduction
3. Project Creation
4. Jetbrains Rider - 4 Month Free Coupon
5. Project Creation
6. Setting up Version Control
7. The Base Character Class
8. Player and Enemy Characters
9. Character Blueprint Setup
10. Animation Blueprints
11. Enhanced Input
12. Aura Player Controller
13. Movement Input
14. Game Mode
15. Enemy Interface
16. Highlight Enemies
17. Post Process Highlight
18. Section 2 Quiz
19. Intro to the Gameplay Ability System
20. The Gameplay Ability System
21. The Main Parts of GAS
22. The Player State
23. Ability System Component and Attribute Set
24. GAS in Multiplayer
25. Constructing the ASC and AS
26. Replication Mode
27. Init Ability Actor Info
28. Section 3 Quiz
29. Attributes
30. Attributes
31. Health and Mana
32. Attribute Accessors
33. Effect Actor
34. Section 4 Quiz
35. RPG Game UI
36. Game UI Architecture
37. Aura User Widget and Widget Controller
38. Globe Progress Bar
39. Health Globe
40. Aura HUD
41. Overlay Widget Controller
42. Broadcasting Initial Values
43. Listening for Attribute Changes
44. Callbacks for Mana Changes
45. Section 5 Quiz
46. Gameplay Effects
47. Gameplay Effects
48. Effect Actor Improved
49. Instant Gameplay Effects
50. Duration Gameplay Effects
51. Periodic Gameplay Effects
52. Effect Stacking
53. Infinite Gameplay Effects
54. Instant and Duration Application Policy
55. Infinite Effect Application and Removal
56. PreAttributeChange
57. PostGameplayEffectExecute
58. Curve Tables for Scalable Floats
59. Section 6 Quiz
60. Gameplay Tags
61. Gameplay Tags
62. Creating Gameplay Tags in the Editor
63. Creating Gameplay Tags from Data Tables
64. Adding Gameplay Tags to Gameplay Effects
65. Apply Gameplay Tags with Effects
66. Gameplay Effect Delegates
67. Get All Asset Tags
68. Broadcasting Effect Asset Tags
69. UI Widget Data Table
70. Retrieving Rows from Data Tables
71. Broadcasting Data Table Rows
72. Message Widget
73. Animating the Message Widget
74. Replacing Callbacks with Lambdas
75. Ghost Globe
76. Properly Clamping Attributes
77. Section 7 Quiz
78. RPG Attributes
79. Initialize Attributes from a Data Table
80. Initialize Attributes with Gameplay Effects
81. Attribute Based Modifiers
82. Modifier Order of Operations
83. Modifier Coefficients
84. Secondary Attributes
85. Derived Attributes
86. Custom Calculations
87. Player Level and Combat Interface
88. Modifier Magnitude Calculations
89. Initializing Vital Attributes
90. Section 8 Quiz
91. Attribute Menu
92. Attribute Menu - Game Plan
93. Attribute Menu - Framed Value
94. Attribute Menu - Text Value Row
95. Attribute Menu - Text Value Button Row
96. Attribute Menu - Construction
97. Button Widget
98. Wide Button Widget
99. Opening the Attribute Menu
100. Closing the Attribute Menu
101. Plan for Displaying Attribute Data
102. Gameplay Tags Singleton
103. Aura Asset Manager
104. Native Gameplay Tags
105. Attribute Info Data Asset
106. Attribute Menu Widget Controller
107. Aura Ability System Blueprint Library
108. Constructing the Attribute Menu Widget Controller
109. Attribute Info Delegate
110. Widget Attribute Tags
111. Mapping Tags to Attributes
112. Responding to Attribute Changes
113. Section 9 Quiz
114. Gameplay Abilities
115. Gameplay Abilities
116. Granting Abilities
117. Settings on Gameplay Abilities
118. Input Config Data Asset
119. Aura Input Component
120. Callbacks for Ability Input
121. Activating Abilities
122. Click To Move
123. Setting Up Click to Move
124. Setting Up Auto Running
125. Implementing Auto Running
126. Code Clean Up
127. Aura Projectile
128. Aura Projectile Spell
129. Spawning Projectiles
130. Section 10 Quiz
131. Ability Tasks
132. Ability Tasks
133. Sending Gameplay Events
134. Spawn FireBolt from Event
135. Custom Ability Tasks
136. Target Data
137. Send Mouse Cursor Data
138. Receiving Target Data
139. Prediction in GAS
140. Orienting the Projectile
141. Motion Warping
142. Projectile Impact
143. Projectile Collision Channel
144. Projectile Gameplay Effect
145. Enemy Health Bar
146. Ghost Bar
147. Section 11 Quiz
148. RPG Character Classes
149. RPG Character Classes
150. Character Class Info
151. Default Attribute Effects
152. Curve Tables - CSV and JSON
153. Initializing Enemy Attributes
154. Section 12 Quiz
155. Damage
156. Meta Attributes
157. Damage Meta Attribute
158. Set By Caller Magnitude
159. Ability Damage
160. Enemy Hit React
161. Activating the Enemy Hit React Ability
162. Enemy Death
163. Dissolve Effect
164. Floating Text Widget
165. Showing Damage Text
166. Execution Calculations
167. Damage Execution Calculation
168. ExecCalcs - Capturing Attributes
169. Implementing Block Chance
170. Implementing Armor and Armor Penetration
171. Damage Calculation Coefficients
172. Implementing Critical Hits
173. Section 13 Quiz
174. Advanced Damage Techniques
175. The Gameplay Effect Context
176. Custom Gameplay Effect Context
177. NetSerialize
178. Implementing Net Serialize
179. Struct Ops Type Traits
180. Aura Ability System Globals
181. Using a Custom Effect Context
182. Floating Text Color
183. Hit Message
184. Damage Types
185. Mapping Damage Types to Resistances
186. Resistance Attributes
187. Resistance Damage Reduction
188. Multiplayer Test
189. Section 14 Quiz
190. Enemy AI
191. Enemy AI Setup
192. AI Controller Blackboard and Behavior Tree
193. Behavior Tree Service
194. Blackboard Keys
195. Finding the Nearest Player
196. AI and Effect Actors
197. Behavior Tree Decorators
198. Attack Behavior Tree Task
199. Find New Location Around Target
200. Environment Query System

Ready to make games in the amazing world of Unreal Engine 5?

This "critically-acclaimed" and "insanely successful" Unreal Engine course was created in collaboration with Epic Games.

The majority of the course has been fully updated and remastered to Unreal Engine 5. Existing students get all the new material for free.

Learn how to create and mod video games using Unreal Engine 5, even if you're a complete beginner. Unreal is a free-to-use game development engine used by AAA studios and indie developers worldwide. It is a massive and powerful beast, but we break it down step-by-step so you can tame it.

We start super simple so no prior experience of Unreal or coding is needed! With our online tutorials, you'll be amazed at what you can achieve. We believe project-based learning is the best way to learn Unreal Engine, so you’ll create 5 Unreal games!

Already know Unreal and want to learn VR or Multiplayer? Check out our other Unreal courses, just look for the green leaf for our other world-class Unreal courses.

Learn C++, the powerful industry-standard language from scratch. By the end of the course, you'll be very confident in the basics of coding and game development, and hungry to learn more.

"Any serious game programmer needs to know C++"
Jason Gregory, Lead Programmer at Naughty Dog (creators of Uncharted & The Last of Us)

Anyone who wants to learn to create games: Unreal Engine is a fantastic platform which enables you to make AAA-quality games. Furthermore, these games can be created for Windows, consoles, macOS, iOS, Android and Web from a single source!

Benefit from our world-class support from both other students, and the instructors who are on the forums regularly. Go on to build several games including a tank game, and a First Person Shooter.

You will have access to a course forum where you can discuss topics on a course-wide basis, or down to the individual video. Our thriving discussion forum will help you learn and share ideas with other students.

Get plugged into our communities of amazing developers on Facebook (nearly 20k), in our own TA-curated Community (17k views/day), and our student chat group (10k live at any one time).

Start to learn Unreal C++ now, you won't be disappointed!

1. Intro & Setup (New UE5 Content)
2. For users of Unreal 4.22
3. Welcome To The Course
4. Installing Unreal Engine
5. Community & Support
6. Navigating The Viewport
7. Moving & Placing Actors
8. C++ versus Blueprint
9. Helping Us To Help You
10. Warehouse Wreckage (New UE5 Content)
11. Section Intro - Warehouse Wreckage
12. Project Setup
13. UE 5.1 Warning: Starter Content Folder
14. Blueprint Event Graph
15. Physics Simulation
16. Objects and References
17. Adding an Impulse
18. Blueprint Classes and Instances
19. Spawning Actors
20. Data Types
21. Pawns and Actor Location
22. Control Rotation
23. Vector Addition & Multiplication
24. Get Forward Vector
25. Importing Assets
26. Geometry Brushes (BSP)
27. Materials and Lighting
28. Actor Components
29. Collision Meshes
30. Variables
31. Booleans and Branches
32. Functions
33. Return Types
34. Pure Functions
35. Member Functions
36. Loading Levels & Delay Nodes
37. Wrap-up and Recap
38. Obstacle Assault (New UE5 Content)
39. Section Intro - Obstacle Assault
40. Project Setup
41. Customizing The Character
42. Compilers and Editors
43. UE 5.1 Warning: Installing .NET 6
44. PC - Installing Visual Studio
45. Mac - Installing XCode
46. Installing VSCode
47. Compiling a C++ Project
48. UPROPERTY Variables
49. Live Coding Issues
50. C++ Files & BeginPlay
51. Using Structs In C++
52. Calling Functions in C++
53. Tick
54. Local Variables
55. Pseudo Code
56. Function Return Values
57. Velocity & DeltaTime
58. Scope Resolution Operator
59. If Statements
60. Using Member Functions
61. Blueprint Child Classes
62. Forcing Character Collisions
63. GameMode
64. Writing To The Output Log
65. FString
66. Member Functions
67. Return Statements
68. Const Member Functions
69. FRotator
70. Level Design & Polish
71. Obstacle Assault: Wrap-Up
72. Crypt Raider (New UE5 Content)
73. Section Intro - Crypt Raider
74. Project Setup
75. Modular Level Design
76. Modular Level Layout
77. Solution: Modular Level Layout
78. Light Types
79. Lumen & Light Bleed
80. Level Lighting
81. Character Blueprint
82. Inheritance vs Composition
83. C++ Actor Component
84. Pointer Types & GetOwner()
85. Dereferencing & Arrow (->) Operator
86. Linkers, Headers and Includes
87. FMath::VInterpConstantTo
88. Scene Components
89. Line Tracing & Sweeping
90. GetWorld()
91. DrawDebugLine()
92. References vs Pointers
93. Const References & Out Parameters
94. Geometry Sweeping
95. Input Action Mappings
96. Input Action Mappings
97. Blueprint Callable
98. FindComponentByClass() & nullptr
99. DrawDebugSphere()
100. Grabbing With Physics Handle
101. Waking Physics Objects
102. Returning Out Parameters
103. Overlap Events
104. Constructors
105. TArray
106. While & For Loops
107. Range Based For Loops
108. Actor Tags
109. Early Returns
110. Dependency Injection
111. Casting & Actor Attachment
112. Adding and Removing Tags
113. Boolean Logical Operators
114. Level Polish
115. Crypt Raider: Wrap-Up
116. Toon Tanks (v2)
117. Project Intro
118. Pawn Class Creation
119. Creating Components
120. Forward Declaration
121. Constructing The Capsule
122. Static Mesh Components
123. Deriving Blueprint Classes
124. Instance vs Default
125. Editing Exposed Variables
126. Exposing The Components
127. Creating Child C++ Classes
128. Possessing The Pawn
129. Handling Input
130. Local Offset
131. Movement Speed
132. Local Rotation
133. Casting
134. Using the Mouse Cursor
135. Rotating the Turret
136. The Tower Class
137. Fire
138. Timers
139. The Projectile Class
140. Spawning The Projectile
141. Projectile Movement Component
142. Hit Events
143. Health Component
144. Applying Damage
145. The Game Mode Class
146. Handling Pawn Death
147. Custom Player Controller
148. Starting The Game
149. The Start Game Widget
150. Countdown Timer
151. Displaying Countdown Time
152. Winning And Losing
153. Game Over HUD
154. Hit Particles
155. Smoke Trail
156. Death Particles
157. Sounds
158. Camera Shake
159. Polish And Wrap-Up
160. Simple Shooter
161. Section Intro: Simple Shooter
162. Project Setup
163. Pawns vs Characters in C++
164. Character Movement Functions
165. Controller Aiming
166. Third Person Camera Spring Arm
167. Skeletal Animations 101
168. Editing Collision Meshes
169. Animation Blueprints 101
170. 2D Blend Spaces
171. Connecting Animation To Gameplay
172. Inverse Transforming Vectors
173. Calculating Animation Speeds
174. Gun Actors
175. Spawning Actors At Runtime
176. Attaching To Meshes Via Sockets
177. Shooting Architecture
178. Spawning Particle Effects
179. Player View Point
180. Line Tracing By Channel
181. Impact Effects
182. Dealing Damage To Actors
183. Virtual Methods In C++
184. Overriding TakeDamage
185. Blending Animations By Booleans
186. Blueprint Pure Nodes
187. Create and Setup an AI controller
188. AI Aiming
189. Nav Mesh And AI Movement
190. Checking AI Line Of Sight
191. BehaviorTrees And Blackboards
192. Setting Blackboard Keys In C++
193. Behavior Tree Tasks And Sequences
194. BT Decorators And Selectors
195. Custom BTTasks In C++
196. Executing BTTasks
197. BTTasks That Use The Pawn
198. BTServices In C++
199. Ignoring Actors In Line Traces
200. Ending The Game

Welcome to The Ultimate Unreal Engine 2D Game Development Course.

This is the most comprehensive and effective course you'll ever find about making 2D and 2D/3D hybrid games with Unreal Engine 5.

Through teaching Unreal Engine on YouTube and also in person at a Japanese Game Dev school for the past couple of years I've gained an understanding of what students are really looking for and designed this course to teach you Paper 2D and PaperZD step by step in a structured manner.

If you're completely new to Unreal Engine you can check out the Unreal Engine 5 Crash Course which is included in one of the early chapters.

We'll start out slowly by making a one-button-minigame that teaches you about how to import sprites and use them in your scene. You'll also learn about project settings we need to adjust and about the enhanced input action system which we'll use throughout all of the other chapters in this course as well.

The second game will teach you all about using sprite sheets and how we can create flipbooks.

We'll also look at how to switch between the idle and run flipbook during gameplay and how to play footstep sounds on the correct animation frames.

Since we want the background to be dynamically adjustable I'll also teach you how we can use a background sprite in a blueprint, attach collisions to them and dynamically change them in the construction script depending on how long we want the stage to be.

The Third game is a classic platformer game and will be the first projects using the free PaperZD plugin to improve the workflow of making 2D games with Unreal Engine.

Here you'll learn how to set up an animation source and animation blueprint file with PaperZD and use them to create animation graphs and animation notifies.
We'll also create enemies that can detect walls and ledges to change the direction they walk in and can interact with the player when being stomped on or touching the player character.

You'll also learn how to create a one-way platform that we can jump through form the bottom, but don't fall through from the top.

The forth game will combine all the things we've learned and will be the first 2D/3D hybrid game we create.

This means that our characters are 2D pixel art, however the backgrounds are 3D environments which allow us to make use of all of the amazing features of Unreal Engine.

For this game we don't only have platformer mechanics, but we'll also implement hitboxes, a stun system a damage system and many more things you'll need to know about for most of your games.

To lean into metroidvania mechanics we also create an unlockable sword throw ability, which allows you to stick swords into the wall and use them as platforms to reach higher areas.

1. Course Orientation
2. Curriculum Overview
3. Why make 2D Games with Unreal Engine?
4. What version of Unreal Engine to use
5. How to ask for help
6. Backing up your Projects
7. Unreal Engine 5 Crash Course
8. About the UE 5 Crash Course
9. How to Install Unreal Engine 5
10. How to create a new Project
11. How to navigate the Editor
12. Content Drawer and Blueprints
13. How to make a simple Blueprint
14. Adding functionality to our Blueprint
15. Useful Keyboard Shortcuts and Tips
16. How to debug your games
17. Paper 2D Basics
18. What is Paper 2D?
19. 2D Project Settings
20. Where to find 2D assets for Unreal Engine
21. Quick Draw Project
22. Quick Draw Overview
23. Downloading the Quick Draw Assets
24. Preparing our Sprites
25. Finding the Translucent Material
26. Making a Level Mockup
27. Creating our Samurai Blueprint
28. Moving Sprites with Timelines
29. Inheritance and Child Blueprints
30. Setting up the Game's Rules and Phases
31. If your input isn't working
32. Setting up the Player Input
33. Adding a Camera and Adjusting Project Settings
34. Fixing Black Dot in middle of screen when playing
35. Making the Player Attack
36. Attack Movement through Timelines
37. Adding the Defeated State
38. Creating Simple Enemy AI
39. Resetting the Game
40. Finishing Up
41. Texture Settings for making game builds
42. Finished Project Files
43. Mash Runner Project
44. Mash Runner Overview
45. Downloading the Mash Runner Assets
46. Setting Up the Project and Importing Assets
47. Sprite Sheets and Flipbooks
48. Creating the Runner Blueprint
49. Possessing the Runner Character
50. Making the Character Move
51. Using the Run Animation
52. Improving the Input
53. Adding Speed Curves
54. Triggering Events on Certain Frames
55. Creating the Stage
56. Making the Enemy Runner AI
57. Goal Collision setting issue
58. Setting Up the Goal
59. Finishing Up
60. Finished Project Files
61. PaperZD Introduction
62. What is PaperZD?
63. PaperZD download changes
64. Installing PaperZD
65. Tower Climb Platformer Project
66. Tower Climb Platformer Overview
67. Downloading the Tower Climb Assets
68. Creating Flipbooks Through a JSON File
69. Creating a PaperZD Character Blueprint
70. Making the Character Walk and Jump
71. Setting Up Our Animation Source and Using Our First Notify
72. Creating a PaperZD Animation Blueprint
73. Creating Our First Tile Set
74. Creating A Tile Map
75. Improving the Character Feel
76. Setting Up the Enemy Blueprint
77. Enemy AI Ledge and Wall Detection
78. Defeat Player On Enemy Touch
79. Improving the Player Defeated State
80. Defeat Enemy On Being Stomped
81. Making Platform Blueprints
82. Making a Spring Launcher
83. Designing a Level
84. Implementing Coyote Time
85. Implementing Jump Buffer
86. Finishing Up
87. Finished Project Files
88. Action Platformer Project
89. Action Platformer Overview
90. Downloading the Action Platformer Assets
91. Setting Up the Project Base
92. Setting Up Player Inputs and Movement
93. Setting Up Player Animations with PaperZD
94. Animation Override for Slash Attack
95. Update to PaperZD Anim Notify States
96. Creating and Triggering Hitboxes
97. Implementing the Stun State
98. Health System and Applying Damage
99. Hitstop and Sprite Shake
100. Creating the Enemy Base
101. Setting Up the Enemy AI
102. Stunning the Enemy AI
103. Making the Enemy Change Directions
104. Allowing the Enemy to Attack
105. Handling Aggro
106. Creating the Ability System
107. Creating the Sword Throw
108. Adding the Sword Throwing Animations
109. Environment Assets Availability
110. Adding the Map
111. Adding the Goal and Spawners
112. Improving the Visuals
113. Finishing Up
114. Finished Project Files
115. Extra: Some Tips and Updates
116. Using the Orthographic Camera
117. How to use the 2D Side Scroller Template
118. Bonus: What's next?
119. Bonus Lecture