Unreal Multiplayer Master: Online Game Development In C++
4.6 (1,358 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
20,710 students enrolled

Unreal Multiplayer Master: Online Game Development In C++

Created in collaboration with Epic Games. Use Unreal for online game dev in C++. Covers LAN, VPN, Steam and more.
4.6 (1,358 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
20,710 students enrolled
Last updated 5/2020
English
English [Auto], Indonesian [Auto], 5 more
  • Polish [Auto]
  • Portuguese [Auto]
  • Romanian [Auto]
  • Spanish [Auto]
  • Thai [Auto]
Current price: $119.99 Original price: $199.99 Discount: 40% off
2 days left at this price!
30-Day Money-Back Guarantee
This course includes
  • 24 hours on-demand video
  • 8 articles
  • 2 downloadable resources
  • Full lifetime access
  • Access on mobile and TV
  • Assignments
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Build multiplayer games.
  • Share games with a large audience.
  • Connect games via the Steam APIs.
  • Understand the challenges of computer networks.
  • Understand how Unreal replicates state.
  • Build UI with UMG and C++.
Course content
Expand all 113 lectures 24:05:41
+ Puzzle Platforms - Connecting Players
23 lectures 04:45:01
  • Why you should take the course.
  • We overview the journey.
  • What are the prerequisites?

(Unique Video Reference: 0_PP_UEM)

Preview 01:58
  • Overview of the course structure.
  • What will we cover this section.
  • Let's get stuck in!

(Unique Video Reference: 0b_PP_UEM)

Introduction to Puzzle Platforms
02:03
  • Notes on Unreal versions
  • Creating the base project
  • Testing with multiple players
  • What's under the hood
  • Finding an Unreal .gitignore

(Unique Video Reference: 1_PP_UEM)

Preview 12:02
  • Source control and where to get code
  • Our community site
  • Reading the slides
  • Our rich community

(Unique Video Reference: 2_PP_UEM)

How to Be an Active Student
13:56
  • Overview of multiplayer game types
  • Outlining the journey
  • Sharing our ambitions

(Unique Video Reference: 3_PP_UEM)

Surveying the Multiplayer Space
11:14
  • Client-Server vs Peer-to-Peer
  • Launching a game from the command-line.
  • Launching a dedicated server.
  • Join with clients.

(Unique Video Reference: 4_PP_UEM)

Preview 19:09
Tips For Not Spawning
00:15
  • Create a AStaticMeshActor subclass.
  • Adding mobility in C++.
  • Running code only on the server.

(Unique Video Reference: 5_PP_UEM)

Preview 17:57
Mid-section Quiz
5 questions
  • Understand Actor "Authority"
  • Enable replication of movement
  • What happens with disagreement

(Unique Video Reference: 6_PP_UEM)

Preview 16:51
  • Adding 3D gizmos to a UPROPERTY.
  • Vector for A to B travel.
  • Moving our platform.

(Unique Video Reference: 7_PP_UEM)

Widgets For FVector Properties
16:01
  • What we want to achieve.
  • Continuing past the target.
  • Swapping the start and target.

(Unique Video Reference: 8_PP_UEM)

Sending The Platform Back
14:37
  • Better jump controls.
  • Layout a puzzle.

(Unique Video Reference: 9_PP_UEM)

Set Up A Simple Puzzle
14:19
  • Local vs global internet.
  • Simulating LAN with Hamachi.
  • Connecting Unreal over Hamachi.
  • Getting connected with others.

(Unique Video Reference: 9b_PP_UEM)

Playing Over The Internet
15:51
  • Create the C++ class.
  • Add a box component.
  • Tweak the Blueprint.
  • Place it in the world.

(Unique Video Reference: 10_PP_UEM)

Set Up A Platform Trigger
17:08
Mid-section Quiz
6 questions
  • Implement the handler function.
  • Register the event callback.
  • Reloading the map to call constructors.
  • Repeat for EndOverlap.

(Unique Video Reference: 11_PP_UEM)

Handling Overlap Events In C++
14:04
  • The desired behaviour.
  • Creating the platform interface.
  • TArray for hooking up platforms.
  • Implementing the logic.

(Unique Video Reference: 12_PP_UEM)

Activating Platforms From Triggers
22:45
  • What is a GameInstance?
  • Set a custom GameInstance for you project.
  • Init vs Constructor.

(Unique Video Reference: 13_PP_UEM)

When To Use A GameInstance
14:21
  • What is the console.
  • What classes support Exec functions.
  • Creating out own.
  • How to log to the screen from C++.
  • Dealing with arguments.

(Unique Video Reference: 14_PP_UEM)

Console Commands With Exec
14:31
  • Creating a Lobby.
  • What is travelling?
  • Hosting a server with travel.
  • Testing with and without ?listen.

(Unique Video Reference: 15_PP_UEM)

Hosting Servers With ServerTravel
15:33
  • ClientTravel vs ServerTravel.
  • Getting the PlayerController.
  • Implementing ClientTravel.

(Unique Video Reference: 16_PP_UEM)

Joining Servers With ClientTravel
09:18
  • Building your game.
  • Introduction to Itch.io.
  • A note on security.
  • Sharing our game.

(Unique Video Reference: 17_PP_UEM)

Sharing Your Game On Itch.io
19:25
  • Well done!
  • Get inspired to extend your project.
  • Make sure you're ready for the next section.

(Unique Video Reference: 99_PP_UEM)

Puzzle Platforms Wrap-up
01:21
End Of Section Quiz
7 questions
The UE4 Network Compendium
00:21
+ Menu System - Polishing Our Game
22 lectures 04:23:42
  • Overview of the section.
  • Why we need to cover UI.

(Unique Video Reference: 0_MS_UEM)

Introduction to Menu System
01:00
  • Importing last section's project.
  • Creating a menu Blueprint.
  • Revision of layout.
  • Create a basic menu.

(Unique Video Reference: 1_MS_UEM)

Create a Menu Blueprint
17:36
  • Using the FClassFinder.
  • Finding BP_PlatfromTrigger.
  • Accessing UMG from C++.
  • Saving our menu class.

(Unique Video Reference: 2_MS_UEM)

Accessing UI Classes in C++
19:56
  • Creating an interface.
  • CreateWidget in C++.
  • Setup a MainMenu level.

(Unique Video Reference: 3_MS_UEM)

Load And Display UMG In C++
10:09
Potential Error Messages
00:06
  • Using SetInputMode().
  • Configuring an input mode.
  • Displaying the cursor.
  • Repeat for yourselves.

(Unique Video Reference: 4_MS_UEM)

Changing UI Input Modes
12:25
  • How container widgets work.
  • Canvas panel.
  • Horizontal/vertical boxes.
  • Size boxes as spacers.
  • Overlay.
  • Create a layout.

(Unique Video Reference: 5_MS_UEM)

Advanced UMG Widget Layout
19:09
Mid-section Quiz
5 questions
  • 9-slice images for buttons.
  • Box vs border vs image.
  • Using Google fonts.
  • Scale box for backgrounds.
  • Make it pretty.

(Unique Video Reference: 6_MS_UEM)

Custom Buttons And Fonts
13:45
  • We make our menu pretty.

(Unique Video Reference: 7_MS_UEM)

Solution: Custom Buttons And Fonts
07:34
  • Create a UUserWidget class.
  • Reparent the widget BP.
  • Add a bind widget property.
  • What do the errors mean?

(Unique Video Reference: 8_MS_UEM)

Connecting UMG to C++
09:05
  • How to Initialize a UserWidget.
  • The UButton OnClick handler.
  • Add a dynamic handler.

(Unique Video Reference: 9_MS_UEM)

Initialisers and UButton Callbacks
11:54
  • Intro to inverting dependencies.
  • How to make a interface in Unreal.
  • Using an interface for callbacks.
  • Injecting the dependency.

(Unique Video Reference: 10_MS_UEM)

Interfaces To Invert Dependencies
15:59
  • We solve last lecture's challenge.

(Unique Video Reference: 11_MS_UEM)

Solution: Injecting Dependencies
06:08
Mid-section Quiz
6 questions
  • Refactoring our menu setup.
  • Creating a teardown stub.
  • Reversing the setup logic.

(Unique Video Reference: 12_MS_UEM)

Deactivating Menus
13:11
  • What are widget switchers.
  • Creating a "Join" menu.
  • Styling the menu.

(Unique Video Reference: 13_MS_UEM)

Sub-Menus With Widget Switchers
07:40
  • We finish styling out menu.

(Unique Video Reference: 14_MS_UEM)

Solution: Styling Our Sub-Menu
12:57
  • Binding the WidgetSwitcher.
  • Investigating the API.
  • Switching menus.
  • Implement a back button.

(Unique Video Reference: 15_MS_UEM)

Navigating Menus In C++
15:23
  • Set startup level.
  • Bind the text field.
  • Call the Join() function.

(Unique Video Reference: 16_MS_UEM)

Reading Text Fields From C++
18:32
  • Create the new widget.
  • Create the layout.
  • Load on ESC key in level.
  • Create a UMenuWidget.

(Unique Video Reference: 17_MS_UEM)

Challenge: Loading In-Game Menus
21:21
  • The challenge spec.
  • Hook up the cancel button.
  • Hook up the quit button.

(Unique Video Reference: 18_MS_UEM)

Challenge: Leaving A Server
15:39
  • How to quit from the console.
  • Running console commands from C++.
  • Quitting from a button press.

(Unique Video Reference: 19_MS_UEM)

Quitting A Game From C++
13:12
End Of Section Quiz
6 questions
  • How to polish your menu system.
  • Share it with other students.

(Unique Video Reference: 99_MS_UEM)

Menu System Wrap-up
01:01
+ Online Multiplayer
31 lectures 06:40:02
  • We overview the section topic.

(Unique Video Reference: 0_SM_UEM)

Introduction to Steam Multiplayer
01:04
  • Introducing Steamworks.
  • Downloading the Steamworks SDK.
  • Steamworks and the Online Sub-System.

(Unique Video Reference: 1_SM_UEM)

Getting The Steamworks SDK
09:02
Errors Building SpaceWar
00:35
  • Introducing the Steamworks example project.
  • Updating the project.
  • Downloading & installing DirectX SDK.
  • Fixing the build errors.

(Unique Video Reference: 2_SM_UEM)

Building SpaceWar In Visual Studio
16:06
  • Introducing the Steamworks example project.
  • Applying recommended settings.
  • Running with Steam.

(Unique Video Reference: 3_SM_UEM)

Building SpaceWar In Xcode
08:52
  • Finding a testing partner.
  • Testing servers.
  • Testing lobbies.

(Unique Video Reference: 4_SM_UEM)

Testing Steam Lobbies
09:15
  • Importing PuzzlePlatforms.
  • Capabilities of Online Sub-Systems.
  • Including the OSS module.
  • Getting a pointer to the sub-system.

(Unique Video Reference: 5_SM_UEM)

The Online Sub-System
16:16
  • Role of the NULL sub-system.
  • Configuring the NULL service.
  • Printing the current service name.

(Unique Video Reference: 6_SM_UEM)

NULL Sub-System For Testing
09:49
  • Stack vs Heap.
  • Manual memory management.
  • Reference counting with TSharedPtr.
  • Garbage Collection of UObjects.

(Unique Video Reference: 7_SM_UEM)

Memory Management In C++
13:32
Mid-section Quiz
5 questions
  • Creating a session.
  • Asynchronous operations and delegates.
  • Creating a session on host.

(Unique Video Reference: 8_SM_UEM)

Creating Online Sessions
16:39
  • Asynchronous destruction.
  • Checking if a session exists.
  • Destroy the session if we need to.

(Unique Video Reference: 9_SM_UEM)

Destroying Online Sessions
11:44
  • FindSessions and TShareRef.
  • Handling OnFindSessionsCompleteDelegates.

(Unique Video Reference: 10_SM_UEM)

Finding Online Sessions
12:08
  • Configuring Session Settings.
  • Adding query parameters.
  • Iterating over a TArray

(Unique Video Reference: 11_SM_UEM)

Query Parameters & Session Settings
12:11
  • Introduction to the ScrollBox.
  • Creating a row widget.
  • Add rows in C++.

(Unique Video Reference: 12_SM_UEM)

Lists Of Widgets With ScrollBox
20:16
  • Expose the text property.
  • Setting a server list from GameInstance.
  • Clearing the previous list.
  • Requesting a refresh.

(Unique Video Reference: 13_SM_UEM)

Populating The Server List
20:15
Mid-section Quiz
6 questions
  • Using TOptional values.
  • Setup the UServerRow.
  • Adding a UButton.
  • Set the selected index.

(Unique Video Reference: 14_SM_UEM)

Selecting A Server
18:43
  • Passing the index to GameInstance.
  • How to JoinSession.
  • Handling OnJoinSessionComplete.
  • Getting the platform connect string.

(Unique Video Reference: 15_SM_UEM)

Joining A Session
15:38
  • Enabling the steam plugin.
  • Compiling with the steam module.
  • Configuring the DefaultEngine.ini.
  • Reading the verbose logs.

(Unique Video Reference: 16_SM_UEM)

Enabling The Steam OSS
13:28
Enabling Steam In Packaged Builds
00:31
  • Enabling presence for the server.
  • Enabling presence for search.
  • Debugging our connection.

(Unique Video Reference: 17_SM_UEM)

"Presence" For Steam Lobbies
14:48
Mid-section Quiz
5 questions
  • Update text colour on hover.
  • Update all rows when Selected.
  • Select colors for Hovered and Selected.

(Unique Video Reference: 18_SM_UEM)

Row Selection In Lists
18:40
  • Disabling Steam for testing.
  • Creating a struct.
  • Populating the struct.
  • Updating the UI.

(Unique Video Reference: 19_SM_UEM)

Displaying Search Result Properties
21:05
  • Disabling Steam fully.
  • Getting the available connections.
  • Padding the text properly.

(Unique Video Reference: 20_SM_UEM)

Debugging The Search Results
11:08
  • How to set custom settings.
  • How to retrieve custom settings.
  • Setting the server name.

(Unique Video Reference: 21_SM_UEM)

Custom Session Settings
19:06
  • We finish the challenge solution.
  • We make our menu pretty again.

(Unique Video Reference: 22_SM_UEM)

Continued: Custom Session Settings
13:42
Mid-section Quiz
5 questions
  • Joining into the lobby.
  • Creating a GameMode override.
  • Handling PostLogin.
  • Handle Logout and count players.

(Unique Video Reference: 23_SM_UEM)

GameMode And Multiplayer
18:07
  • Ensuring we call Super.
  • Traveling to the game.
  • What is non-seamless travel?
  • Enabling seamless travel.
  • The transition map.

(Unique Video Reference: 24_SM_UEM)

Enabling Seamless Travel
15:19
  • Installing editor symbols.
  • Finding the NULL subsystem code.
  • What code should be called?
  • Attaching and debugging.
  • Fixing the NULL subsystem bug.

(Unique Video Reference: 25_SM_UEM)

Debugging Engine Code
19:43
Bugs In Steam OSS
00:18
  • Update maximum number of players.
  • Adding a session start timeout.
  • Starting the session.

(Unique Video Reference: 26_SM_UEM)

Starting A Session
20:45
End Of Section Quiz
4 questions
  • We review the topics covered this section.

(Unique Video Reference: 99_SM_UEM)

Steam Multiplayer Wrap-up
01:17
+ Krazy Karts - State Synchronisation And Interpolation
36 lectures 08:16:29
  • We overview the sections topics.

(Unique Video Reference: 0_KK_UEM)

Introduction to Krazy Karts
01:17
  • Create the project.
  • Create a pawn.
  • Setup GameMode Spawning.
  • Setup Camera.
  • Attach throttle controls.

(Unique Video Reference: 1_KK_UEM)

Creating A Go-Kart Pawn
17:36
  • Revision of forces in physics.
  • Calculating movement from force.
  • Providing the driving force.

(Unique Video Reference: 2_KK_UEM)

Understanding Forces And Movement
12:50
  • Setting up collision volumes.
  • Sweeping with AddActorWorldOffset.
  • Resetting velocity on collision.
  • Refactoring the Tick function.

(Unique Video Reference: 3_KK_UEM)

Blocking Movement Without Physics
15:03
  • Angle axis rotations with FQuat.
  • Adding rotations actors.
  • Rotating our velocity.

(Unique Video Reference: 4_KK_UEM)

Rotations With Quaternions
14:48
  • Understanding air resistance.
  • Getting the "speed".
  • Calculating force due to air resistance.

(Unique Video Reference: 5_KK_UEM)

Simulating Air Resistance
14:39
Mid-section Quiz
5 questions
  • What is rolling resistance?
  • Finding the gravity in Unreal.
  • Implementing rolling resistance.
  • Example rolling resistance coeffients.

(Unique Video Reference: 6_KK_UEM)

Simulating Rolling Resistance
11:55
  • Why we get turning circles.
  • Calculating our rotation geometry.
  • Correcting steering behaviour.

(Unique Video Reference: 7_KK_UEM)

Steering And Turning Circles
15:23
  • How to change state from the client.
  • Introduction to RPC server functions.
  • What is validation?
  • Implementing validation for input.

(Unique Video Reference: 8_KK_UEM)

Server Functions & Cheat Protection
17:35
  • What are Actor roles?
  • Investigating the network roles.
  • Updating the AutonomousProxy.

(Unique Video Reference: 9_KK_UEM)

AutonomousProxy vs SimulatedProxy
18:18
  • How simulation error effect our game.
  • Overview the different sources of error.
  • Investigate approaches to eliminating them.

(Unique Video Reference: 10_KK_UEM)

Sources Of Simulation Error
11:58
Mid-section Quiz
5 questions
  • Overview of property replication.
  • Replicating the actor position.
  • Setting and reading the property.
  • Replicating the actor rotation.

(Unique Video Reference: 11_KK_UEM)

Replicating Variables From The Server
16:59
  • Deep dive on property replication.
  • Setting the network update interval.
  • Notify on replicate.
  • Simulate between updates.

(Unique Video Reference: 12_KK_UEM)

Triggering Code On Replication
12:04
  • Replicating velocity.
  • Why is movement jerky?
  • Replicating control input to SimulatedProxy.

(Unique Video Reference: 13_KK_UEM)

Smooth Simulated Proxies
08:36
  • What is lag?
  • Simulating lag and packet loss.
  • Why does lag cause glitching?

(Unique Video Reference: 14_KK_UEM)

Simulating Lag And Packet Loss
18:25
  • Why do we reset when accelerating?
  • Keeping AutonomousProxy ahead of the Server.
  • What information needs to be sent to the server.
  • Compare our different simulation approaches.

(Unique Video Reference: 15_KK_UEM)

Replay Autonomous Moves
10:43
Mid-section Quiz
5 questions
  • Pseudocode for client prediction.
  • Adding structs for synchronisation.

(Unique Video Reference: 16_KK_UEM)

Planning Client-Side Prediction
16:21
  • What do we have already?
  • Replicating state via a struct.
  • Sending the Move struct via RPC.

(Unique Video Reference: 17_KK_UEM)

Replicating Structs
19:16
  • The SimulateMove signature.
  • Updating the canonical state.
  • Implement SimulateMove.

(Unique Video Reference: 18_KK_UEM)

Simulating A Move
11:26
  • TArray for the Move queue.
  • Tidying the move creation code.
  • Printing the queue length.
  • Removing acknowledged moves.

(Unique Video Reference: 19_KK_UEM)

Unacknowledged Move Queue
15:37
Server Time vs Local Time
00:12
  • Simulate all moves.
  • Testing for smoothness.
  • How can we still make it glitch?

(Unique Video Reference: 20_KK_UEM)

Simulating Unacknowledged Moves
09:59
  • Ensuring the Server simulates once.
  • Local prediction on the client.
  • Making smoother predictions.

(Unique Video Reference: 21_KK_UEM)

Fixing SimulatedProxy Prediction
13:13
Mid-section Quiz
5 questions
  • Red-Green-Refactor process.
  • How to spot your "code smells".
  • Identifying a suitable refactor.
  • Planning our refactor.

(Unique Video Reference: 22_KK_UEM)

Refactoring Into Components
12:23
  • Create and name the component.
  • Move member declarations across.
  • Move function implementations.
  • Fix build errors.

(Unique Video Reference: 23_KK_UEM)

Extracting A Movement Component
18:29
  • Creating the component.
  • Enable replication.
  • Move member declarations across.
  • Move function implementations.
  • Fix build errors.

(Unique Video Reference: 24_KK_UEM)

Extracting A Replication Component
18:58
  • What happens if we disable the replicator?
  • Allow the Movement Component to tick.
  • Getting the information to replicate.

(Unique Video Reference: 25_KK_UEM)

Decoupling Movement & Replication
17:06
Mid-section Quiz
4 questions
  • How does linear interpolation work?
  • Overview of client interpolation.
  • Pseudocode for client interpolation.

(Unique Video Reference: 26_KK_UEM)

Linear Interpolation For Position
12:29
  • Ensure movement replication is off.
  • Updating the time variables.
  • FMath::Lerp vs FMath::LerpStable.
  • Implementing the pseudocode.

(Unique Video Reference: 27_KK_UEM)

FMath::Lerp For Client Interpolation
21:26
  • Slerp vs Lerp.
  • Store tranform instead of location.
  • Implementing Slerped location.

(Unique Video Reference: 28_KK_UEM)

FQuat::Slerp For Rotation
11:33
  • Understanding jarring movement.
  • How velocity can help or hinder.
  • A brief overview of polynomials.
  • Introducing the Hermite Cubic Spline.

(Unique Video Reference: 29_KK_UEM)

Hermite Cubic Spline Interpolation
07:54
  • Slopes, derivatives and velocity.
  • Using CubicInterp for location.
  • Using CubicInterpDerivative for velocity.

(Unique Video Reference: 30_KK_UEM)

FMath::CubicInterp For Velocity
17:09
Mid-section Quiz
5 questions
  • Assessing the existing code.
  • Creating a plain C++ struct.
  • Pulling out methods.

(Unique Video Reference: 31_KK_UEM)

Refactoring With Structs
19:40
  • Understanding mesh offseting.
  • Set up the mesh offset root component.
  • Manipulating the offset instead.

(Unique Video Reference: 32_KK_UEM)

Client Interpolation Mesh Offset
16:26
  • Bounding the inputs.
  • Stressing our DeltaTime.
  • Tracking simulation time.

(Unique Video Reference: 33_KK_UEM)

Advanced Cheat Protection
16:22
Mid-section Quiz
3 questions
  • Congratulations on making it this far!
  • Why we don't cover dedicated server.
  • How to continue practicing your skills

(Unique Video Reference: 99_KK_UEM)

End Of Course Wrap-up
02:21
+ Continuing Your GameDev Journey
1 lecture 00:25

Awesome job keeping up with our content creation! While you're waiting for more, why not check out some of our other courses...

Look forward to seeing you there.
Ben, Sam and the GameDev.tv team

Preview 00:25
Requirements
  • Knowledge of basic C++ including classes and pointer.
  • An understanding of fundamental Unreal concepts such as Pawns and Maps.
  • You should be comfortable creating Blueprints to program simple behaviours.
Description

Created in collaboration with Epic Games, the course will show you how to create Epic multiplayer experiences using the world class Unreal Engine. This course hits the ground running, instantly getting you playing your own multiplayer games with other students.

As the engine underpinning many AAA games (including Fortnite), Unreal is full of tools for creating multiplayer games extremely quickly. However, knowing where to start with Unreal Engine can be intimidating

With a massive feature set and little documentation, you get stuck understanding where to begin. This course makes understanding Unreal super easy. Not only do we show you how to use the engine, but we teach you the fundamental concepts. These skills allow you to pick up new features for yourself.

This course is aimed at beginner to intermediate Unreal users with some knowledge of C++. Not too confident? Don't worry, the course will take you through everything step by step and give you plenty of practice to build up that confidence with coding.

We don't assume any knowledge about networking or multiplayer games. We will teach you about everything you need to know about networks from the basics of latency in networks to the advanced topics of state synchronisation.

This course will not teach you to make a massively multiplayer game. But it will teach you the fundamentals you need to understand how an MMO could be built.

Note: access to this course comes with an optional, free community site where you can share games and 3D models, as well as connect with other students.

Become a multiplayer master now, you won't be disappointed!

Who this course is for:
  • Beginner to intermediate coders.
  • Blueprint users who want to get good at C++.
  • Unreal users who want to understand multiplayer features.