Top 8 Recommended Unreal Engine Self-Study Materials! [December 2023]

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

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.

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. I recommend that you take the following courses before this one, if you haven't already:

Learn C++ for Game Development, by Stephen Ulibarri

Unreal Engine 5 C++ The Ultimate Game Developer Course, by Stephen Ulibarri

OR already have equivalent knowledge, whether you obtained it through self-study or other resources/tutorials. If you already have game development experience and feel like you can handle it, feel free to jump in! If the C++ code seems too over your head, take a look at the above two courses, as they teach you everything you need to know to have a smooth and fun experience in this course. Everything that isn't covered in these two courses will be explained in depth, and I'm assuming you know nothing about GAS or the advanced topics we cover in this course.

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, join the awesome Druid Mechanics Discord Community, 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.

1. Introduction
2. Introduction
3. Project Creation
4. Rider Coupon - 4 Free Months
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

Over 64 hours of content!

Learn all about Unreal Engine multiplayer in this fully comprehensive C++ course. From scratch, we create a complete multiplayer shooter game, capable of creating and joining game sessions and connecting many players across the internet. We'll create our very own custom plugin that can be added to any Unreal Engine project to easily turn it into a multiplayer game.

We learn how to optimize our game for the best performance, as competitive shooters require the highest performance possible. We'll implement lag compensation techniques such as client-side prediction and server-side rewind, so the game performs smoothly even in the presence of high lag!

We learn how to use the proper game classes for each multiplayer mechanic. Custom match states, warmup/cooldown match timers, Elim announcements, HUD with health, shields, ammo and grenades, and more! We keep all important functionality on the server, to prevent cheating, and learn the proper way to use the Player Controller, Game Mode, Game State, Player State, Character and Game Instance classes.

We make assault rifles, pistols, submachine guns, rocket launchers, grenade launchers, sniper rifles and throwing grenades! All functional in multiplayer, optimized for best performance.

After this course, you'll be able to create any multiplayer game you want. If you can do a fast-paced shooter well, you can do any game, because fast-paced, competitive games require the best performance possible.

1. Introduction
2. Introduction
3. About this Course
4. Creating a Multiplayer Plugin
5. Multiplayer Concepts
6. Testing Multiplayer
7. LAN Connection
8. Online Subsystem
9. Online Sessions
10. Configure For Steam
11. Accessing the Online Subsystem
12. Creating a Session
13. Setup for Joining Game Sessions
14. Steam Regions
15. Joining the Session
16. Creating a Plugin
17. Creating our Own Subsystem
18. Session Interface Delegates
19. The Menu Class
20. Accessing our Subsystem
21. Notes on OnLevelRemovedFromWorld
22. Create Session
23. Callbacks to our Subsystem Functions
24. More Subsystem Delegates
25. Session Settings
26. Join Sessions from the Menu
27. Tracking Incoming Players
28. Optional Challenge: Implement StartSession
29. Path to Lobby
30. Polishing the Menu Subsystem
31. Quiz on the Multiplayer Sessions Subsystem
32. Project Creation
33. On Unreal Engine Versions
34. Project Creation
35. What to Add to DefaultEngine.ini
36. Testing an Online Session
37. Find a Test Partner!
38. Assets
39. Retargeting Animations in Unreal Engine 5
40. Retargeting Animations
41. Blaster Character
42. Camera and Spring Arm
43. Character Movement
44. Animation Blueprint
45. Seamless Travel and Lobby
46. Network Role
47. Optional Challenge: Show the Player Name
48. Quiz on Network Role and Seamless Travel
49. The Weapon
50. Weapon Class
51. Pickup Widget
52. Variable Replication
53. Equipping Weapons
54. Remote Procedure Calls
55. Equipped Animation Pose
56. Crouching
57. Aiming
58. Running Blendspace
59. Leaning and Strafing
60. Idle and Jumps
61. Crouch Walking
62. Aim Walking
63. Aim Offsets
64. Applying Aim Offsets
65. Pitch in Multiplayer
66. Using our Aim Offsets
67. FABRIK IK
68. Turning in Place
69. Rotate Root Bone
70. Net Update Frequency
71. Crouch Unequipped
72. Rotating Running Animations
73. Footstep and Jump Sounds
74. Quiz on the Weapon Section
75. Optional Challenge: Crouch Footstep Sounds
76. Firing Weapons
77. Projectile Weapon Class
78. Fire Montage
79. Fire Weapon Effects
80. Fire Effects in Multiplayer
81. The Hit Target
82. Spawning the Projectile
83. Projectile Movement Component
84. Projectile Tracer
85. Replicating the Hit Target
86. Projectile Hit Events
87. Bullet Shells
88. Shell Physics
89. Quiz on Firing Weapons
90. Weapon Aim Mechanics
91. Optional Challenge: Add random rotation to the bullet shells
92. Blaster HUD and Player Controller
93. Drawing the Crosshairs
94. Crosshair Spread
95. Correcting the Weapon Rotation
96. Zoom While Aiming
97. Shrink Crosshairs when Aiming
98. Change Crosshairs Color
99. Extending the Trace Start
100. Hitting the Character
101. Smooth Rotation for Proxies
102. Optional Challenge: Shrink crosshairs when aiming at another player
103. Automatic Fire
104. Testing the Game
105. Quiz on Weapon Aim Mechanics
106. Optional Challenge: Different Hit Particles
107. Health and Player Stats
108. Game Framework
109. Health
110. Update Health in the HUD
111. Damage
112. Blaster Game Mode
113. Elim Animation
114. Respawning
115. Dissolve Material
116. Dissolving the Character
117. Dissolving with Curves
118. Disable Movement when Elimmed
119. Elim Bot
120. On Possess
121. Blaster Player State
122. Defeats
123. Optional Challenge: Display a Message in the HUD when Defeated
124. Quiz on Health and Player Stats
125. Ammo
126. Weapon Ammo
127. Can Fire
128. Carried Ammo
129. Displaying Carried Ammo
130. Reloading
131. Reloading Combat State
132. Allowing Weapon Fire
133. Updating Ammo
134. Reload Effects
135. Auto Reload
136. Optional Challenge: Show the Weapon Type in the HUD for the Equipped Weapon
137. Quiz on Ammo
138. Match States
139. Game Timer
140. Syncing Client and Server Time
141. Match State
142. On Match State Set
143. Warmup Timer
144. Updating Warmup Time
145. Custom Match States
146. Cooldown Announcement
147. Restart Game
148. Blaster Game State
149. Optional Challenge: Blinking Countdown Text
150. Quiz on Match States
151. Different Weapon Types
152. Rocket Projectiles
153. Rocket Trails
154. Spawning Rocket Trails
155. Rocket Movement Component
156. Hit Scan Weapons
157. Beam Particles
158. Submachine Gun
159. Strap Physics
160. Shotgun
161. Weapon Scatter
162. Sniper Rifle
163. Sniper Scope
164. Grenade Launcher
165. Projectile Grenades
166. Reload Animations
167. Shotgun Reload
168. Weapon Outline Effect
169. Grenade Throw Montage
170. Weapon Attachment while Throwing Grenades
171. Grenade Assets
172. Showing the Attached Grenade
173. Spawning Grenades
174. Grenades in Multiplayer
175. Grenades in the HUD
176. Optional Challenge: Create a new Weapon!
177. Quiz on Different Weapon Types
178. Pickups
179. Pickup Class
180. Ammo Pickups
181. Buff Component
182. Health Pickup
183. Healing the Character
184. Speed Buffs
185. Jump Buffs
186. Shield Bar
187. Updating the Shield
188. Shield Buffs
189. Pickup Spawn Point
190. Adding Spawn Points to the Level
191. Spawn Default Weapon
192. Secondary Weapon
193. Swap Weapons
194. Drop the Secondary Weapon
195. Optional Challenge: Custom Pickup!
196. Quiz on Pickups
197. Lag Compensation
198. Lag Compensation Concepts
199. High Ping Warning
200. Local Fire Effects

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. Installing PaperZD
64. Tower Climb Platformer Project
65. Tower Climb Platformer Overview
66. Downloading the Tower Climb Assets
67. Creating Flipbooks Through a JSON File
68. Creating a PaperZD Character Blueprint
69. Making the Character Walk and Jump
70. Setting Up Our Animation Source and Using Our First Notify
71. Creating a PaperZD Animation Blueprint
72. Creating Our First Tile Set
73. Creating A Tile Map
74. Improving the Character Feel
75. Setting Up the Enemy Blueprint
76. Enemy AI Ledge and Wall Detection
77. Defeat Player On Enemy Touch
78. Improving the Player Defeated State
79. Defeat Enemy On Being Stomped
80. Making Platform Blueprints
81. Making a Spring Launcher
82. Designing a Level
83. Implementing Coyote Time
84. Implementing Jump Buffer
85. Finishing Up
86. Finished Project Files
87. Action Platformer Project
88. Action Platformer Overview
89. Downloading the Action Platformer Assets
90. Setting Up the Project Base
91. Setting Up Player Inputs and Movement
92. Setting Up Player Animations with PaperZD
93. Animation Override for Slash Attack
94. Creating and Triggering Hitboxes
95. Implementing the Stun State
96. Health System and Applying Damage
97. Hitstop and Sprite Shake
98. Creating the Enemy Base
99. Setting Up the Enemy AI
100. Stunning the Enemy AI
101. Making the Enemy Change Directions
102. Allowing the Enemy to Attack
103. Handling Aggro
104. Creating the Ability System
105. Creating the Sword Throw
106. Adding the Sword Throwing Animations
107. Adding the Map
108. Adding the Goal and Spawners
109. Improving the Visuals
110. Finishing Up
111. Finished Project Files
112. Course Completed
113. What's next?

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