The Unreal Engine Developer Course - Learn C++ & Make Games

Learn C++ from scratch. How to make your first video game in Unreal engine. Gain confidence in programming.
4.7 (5,167 ratings) Instead of using a simple lifetime average, Udemy calculates a
course's star rating by considering a number of different factors
such as the number of ratings, the age of ratings, and the
likelihood of fraudulent ratings.
31,485 students enrolled Bestselling in Unreal
$19
$195
90% off
Take This Course
  • Lectures 261
  • Length 43.5 hours
  • Skill Level All Levels
  • Languages English
  • Includes Lifetime access
    30 day money back guarantee!
    Available on iOS and Android
    Certificate of Completion
Wishlisted Wishlist

How taking a course works

Discover

Find online courses made by experts from around the world.

Learn

Take your courses with you and learn anywhere, anytime.

Master

Learn and practice real-world skills and achieve your goals.

About This Course

Published 11/2015 English

Course Description

NEW Testing Grounds FPS shipping now, including...

  • Much more C++ and Blueprint.
  • AI Blackboards & Behavior Trees.
  • Environmental Query System (EQS).
  • Humanoid Animation Blending.
  • Never-ending Level Design.


English closed-captions through the course, Spanish in first section only.

This course started as a runaway success on Kickstarter. Get involved now, and get access to all future content as it's added. The final course will be over 50 hours of content and 300+ lectures.

Learn how to create and mod video games using Unreal Engine 4, the free-to-use game development platform used by AAA studios and indie developers worldwide.

We start super simple so you need no prior experience of Unreal or coding! With our online tutorials, you'll be amazed what you can achieve.

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.

You will 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!

If you're a complete beginner, we'll teach you all the coding and game design principles you'll need. If you're an artist, we'll teach you to bring your assets to life. If you're a coder, we'll teach you game design principles.

What this course DOESN'T cover...

Whereas this course is already huge, we can't possibly cover everything in that time. Here are some things we will not be covering...

  • Team collaboration topics.
  • Editor plugins or modifications.
  • Physics engine modification.

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.

Start your transformation now, you won't be disappointed!

What are the requirements?

  • 64-bit Mac or PC capable of running Unreal 4.

What am I going to get from this course?

  • Learn C++, the games industry standard language.
  • Develop strong and transferrable problem solving skills.
  • Gain an excellent knowledge of modern game development.
  • Learn how object oriented programming works in practice.
  • Gain a more fundamental understanding of computer operation.

What is the target audience?

  • Competent and confident with using a computer.
  • Artists who want to bring their assets alive in a game engine.
  • Developers who want to re-skill across to coding.
  • Complete beginners who are willing to work hard.
  • Existing programmers who want to re-skill to game development.

What you get with this course?

Not for you? No problem.
30 day money back guarantee.

Forever yours.
Lifetime access.

Learn on the go.
Desktop, iOS and Android.

Get rewarded.
Certificate of completion.

Curriculum

Section 1: Introduction and Setup
01:48

Ben Tristem explains what this course is, and why you should consider taking it.

02:49
  • Section notes are attached to this video.
  • Who gets the most from this course.
  • What support to expect.
  • How to ask good questions.
  • What if I'm more experienced?
03:03
  • Configure Visual Studio Community 2015.
  • If you’re on MacOS skip ahead 2 mins.

Software changes regularly. If your install options are different please post a screenshot in the Q&A so we can update the course. Thanks.

07:25
  • Start Unreal Engine Downloading too.
  • An overview of the Unreal install process.
  • What is an IDE and why you need it.
05:43
  • Get Visual Studio running.
  • Xcode is covered in the next video.
  • Write your first line of C++ code.
  • Check the code “compiles”.
  • Learn where to find the Output log.
04:24
  • Get Xcode running.
  • Write your first line of C++ code.
  • Check the code “compiles”.
  • Learn where to find the Output.
10:58
  • Expected vs Observed behaviour.
  • Creating a Minimal Viable Test case.
  • Useful information to include.
  • Explaining what has already been tried.
  • Sharing code the smart way.
  • Using Udemy Q&A effectively.
09:46
  • Create a new Basic C++ project.
  • Take a quick look around Unreal.
  • Learn about saving and scenes.
  • Customise the Unreal Editor interface.
10 questions

Check your basic understand of the Unreal ecosystem.

02:43
  • Well done getting setup.
  • Introduce yourself in the discussions.
  • Start the next section NOW.
  • Going from C# to C++.
Section 2: Bulls & Cows Word Console Game - Your First C++
03:03
  • Welcome to the first actual coding video.
  • Why we’re doing this in the IDE only.
  • What you’ll be building, see resources.
  • You’ll learn types, loops, routines, classes.
  • We’ll follow Unreal’s coding style, and re-use.
  • Notes and resources are attached.
07:24
  • How much planning should we do?
  • Define the emotional problem the game solves*
  • Chose concept, rules & requirements.
  • Start to think about the architecture.
  • Copy as much as possible into the code!
  • Document now what may change later.

* McConnell, Steve. Code Complete. Microsoft Press 2004. Chapter 3.3

08:56
  • How projects and solutions relate.
  • Setting up a new command line project.
  • An overview of the structure of our solution.
  • (Adding main.cpp to our project).
07:53
  • The difference between an engine and a library.
  • How this relates to this console application.
  • What is building / compiling code?
  • How the console knows where to find our code.
  • The syntax of a function in C++.
  • Write the minimal C++ program to remove error.
  • Testing our application runs without error.
10:56
  • # represents a “preprocessor directive”.
  • #include copies-and-pastes other code.
  • The idea of using library code.
  • Use <> for standard libraries.
  • Use “ “ for files you have created yourself.
  • Notice the namespace icon in autocomplete.
  • Import iostream library and use std namespace.
07:21
  • What a “magic number” is.
  • Why it’s a good idea to avoid them.
  • constexpr means “evaluated at compile time”.
  • Introduce coding standards*.
  • Use a constant for the word length.
  • *https://docs.unrealengine.com/latest/INT/Programming/Development/CodingStandard/index.html


10:00
  • The difference between \n and endl
  • Introducing pseudocode programming
  • Why we need to #import <string>
  • Getting input using cin
  • Discovering woes with our input buffer.
05:04
  • Re-cap the problem we have.
  • Why getline() is useful here.
  • Where to find C++ documentation.
  • A word on non-obvious solutions.
10:36
  • Programming is all about managing complexity.
  • We want to think about a few things at a time.
  • The idea of abstraction and encapsulation.
  • How functions help us simplify.
  • Write and call your first functions.
  • A warning about “side-effects” of functions.
  • Always use return at the end of your functions.
08:08
  • Why we need loops.
  • When to use for vs while.
  • The syntax of a for loop.
  • Think carefully about the first & last loop.
  • Write a for loop to repeat the game.
10 questions

Consolodate your knowledge so far.

10:19
  • More about levels of abstraction.
  • A word on being clever.
  • Using Visual Studio’s Extract “Extract Function”
  • What a header file (.h) is.
  • What’s refactoring, and why we do it.
  • Removing side-effects.
  • Where to find the course code on GitHub.
10:37
  • What a boolean is, and how to use it.
  • Only use when completely clear what you mean.
  • Use == for comparison.
  • Use && for logical AND.
  • Use || for logical OR.
  • Use [n] to access a string, starting at n=0.
  • Use ‘ ‘ for characters, and “ “ for strings.
06:44
  • What a do while loop is.
  • How it executes code one or more times.
  • Making our game play multiple times.
02:59
  • Lookup the Turing machine.
  • A quick overview of the MVC pattern.
  • User defined types (classes).
  • About working at an interface level (black box).
  • An overview of class FBullCowGame
11:35
  • Introducing .h header files in C++.
  • Why the added complexity is worth it.
  • Defining the interface to our class.
  • Writing our first draft of FBullCowGame.h
09:37
  • NEVER use using namespace in a .h
  • In fact, why use it at all?
  • Create your .cpp files and #include
  • Don’t create chains of includes.
07:00
  • Relax, they’re just user defined types!
  • string FirstName; creates a string object
  • FBullCowGame BCGame; works the same way
  • These instances are initialised by “constructors”
  • Instantiating means “creating an instance of”
  • So we’re simply creating a game instance.
09:00
  • What is a getter method
  • Why we never access variables directly
  • How to call a method using the dot operator
  • Pros and cons of initialising in at compile time
  • Using “Rebuild Project” to make VS behave!
05:37
  • const’s meaning depends on context
  • Generally means “I promise not to change this”
  • What this is depends on exactly where it appears
  • At the end of a member function, for example int GetCurrentTry() const; it prevents the function from modifying any member variables
  • This is a good safety feature.
07:50
  • Default constructor called when object created
  • Initialize in constructor when decided at runtime
  • Initialize in declaration if known at compile time
  • Constructor syntax simply: ClassName();
  • Set the member variables in constructor
  • Test this has worked.
09:07
  • More on Pseudocode Programming Practice (PPP)
  • Reviewing our code and architecture
  • Using // TODO as a comment prefix
  • Introducing Visual Studio’s Task List
  • Planning our next wave of coding.
10 questions

Wow, has it been 10 lectures already? Let's consolodate your knowledge.

09:41
  • We’re substituting types to be “Unreal ready”
  • The declaration is using <alias> = <type>;
  • For example using int32 = int;
  • Why Unreal uses int32 rather than int
  • FText is for output, FString is “mutable”
  • Where to use each type of string
  • Map FText and FString to std::string
10:12
  • struct is almost identical to class
  • It’s member variables (data) is public by default
  • Ideal for simple value types like BullCowCount
  • Outline BullCowCount SubmitGuess(FString)
12:20
  • Why we need conditionals (selection)
  • Use if when it reads better (e.g. few conditions)
  • Use switch for multiple, simple conditions
  • (for loads of statements consider a table lookup)
  • The syntax of an if statement
  • Using if to write count bulls and cows.
09:16
  • A very brief intro to Visual Studio’s debugger
  • Set a break-point by clicking in margin
  • Watch values by highlighting in debug mode
  • Use “Continue” to cycle back to breakpoint.
07:06
  • Centralising the hidden word length
  • Making this a property of the game class
  • Writing a getter to access this value
  • Updating our intro to vary with word length.
09:55
  • An enumerated type consists of named values
  • Use instead of coded meaning
  • Makes the code more readable and meaningful
  • Only defined values can be used - more robust
  • A benefit of C++ 11’s strongly typed enums
  • Creating an enum class for error checking.
09:17
  • Use else if for the first time
  • Outline or CheckGuessValidity() method
  • Write working code for checking guess length
  • Use the debugger to test the return values.
11:57
  • Use our error values to communicate with user
  • All our user interaction is via GameManager.cpp
  • We’ll use FText in this file, as it’s UI text
  • We can “switch” what we say based on the error
  • The syntax of a switch statement
  • Remember your break keywords!
06:31
  • Don’t get comfortable with compiler warnings
  • Refactor GetValidGuess() to remove warning
  • Rename SubmitGuess() to SubmitValidGuess()
  • Improve readability of SubmitValidGuess()
  • Get a warm fuzzy feeling!
07:58
  • Change our PlayGame() loop to a while
  • Implement our IsGameWon() function
10 questions

Wahoo, 10 more lectures down... are you feeling clever yet?

06:07

Write a method to print a game summary to the screen once the game is over.

11:49
  • Algorithm: the recipe for solving a problem
  • or: 45th US Vice President’s dance style
  • Introducing the complexity of algorithms
  • A quick introduction to “Big O” notation
  • Comparing three ways of checking for isograms.
11:09
  • The importance of knowing your data types
  • Introducing the std::map data type
  • #define TMap std::map to keep it ‘Unreal’
  • How we’ll be using the map
  • TMap<char, bool> LetterSeen; to declare
  • Using LetterSeen[Letter] to access
  • Wiring-up and pseudocoding IsIsogram()
08:34
  • Introducing containers and iterators
  • Using a range-based for loop in Unreal*
  • Gently introducing the auto keyword
  • Finishing our IsIsogram()

    *https://www.unrealengine.com/blog/ranged-based-for-loops

08:23
  • Gain confidence with a multi-stage challenge
  • A word on implicit dependencies
07:45
  • Having someone else play test your game is vital
  • Silently take notes, or record screen if possible
  • Immediately go away and fix obvious bugs
  • For improvements consider 2nd or 3rd opinion
  • Repeat until the bug / issue rate plateaus.
09:35
  • About the flow channel*
  • map word length to max tries
  • Play test to determine correct difficulty.
  • * Read more in Sylvester, T. Designing Games - O’Reilly

08:35
  • First impressions count (think reviews)
  • Don’t ship a half-baked product, even if digital
  • Check through your code (polish)
  • Ship to your customers (package).
7 questions

Congratulations on getting this far. Check your knowledge, watch the wrap-up video and start the next section right away!

01:17
  • HUGE congratulations on your progress
  • Over 5 hours of pure C++ learning
  • Over 30 challenges you’ve completed
  • The journey has only just begun
  • Share your source code for others to play
  • Here are some suggested improvements
  • Next we take the game logic into Unreal :-)
Section 3: Building Escape - Your First Unreal C++ Game
02:06
  • Welcome to our first Unreal editor section.
  • You’ll learn simple level building.
  • We’ll be using meshes and materials.
  • C++ events accessed from Blueprint.
  • Calling C++ code from Blueprint.
  • And much more.

View and download the latest slides from Google Slides, link attached.

04:35
The Concept, Rules and Requirements of our simple game.
06:42
  • The what and why of Version Control Systems
  • Choosing your Version Control System (VCS)
  • What files to include / exclude
  • Commit = save a local snapshot
  • Reset = roll-back to a previous state
  • Branch, Push and Large File Support later.
08:45
  • Derived files can be easily rebuilt
  • Other files (code, assets, level layout etc) can’t
  • Ignore most derived files for version control
  • Which folders to ignore in version control
  • Our starting .gitignore file for Unreal.
10:55
  • Understand Unreal creates VS projects for us
  • How to re-generate VS project files
  • Writing our first .gitignore file
  • “Committing” our project for the first time.
08:23
  • Why changes to the starter scene aren’t tracked
  • Arranging a simple set of windows
  • Moving around in the 3D Viewport
  • Setting our start map, and committing
05:40
  • You’re about to meet pointers for the first time
  • The clue is when you see a * next to a type
  • Pointers are simply memory addresses
  • You have to “follow” the pointer to the object
  • Benefit: saves you from moving things in memory
  • Disadvantage: you can lose control of data.
12:46
  • Introducing the idea of inheritance
  • Unreal’s scarily powerful class system
  • Exploring using the Class Viewer*
  • Inheritance for “is a” relationships
  • Components for “has a” relationships.
06:41
  • Using UE_LOG to print to the Output Console
  • Printing to the game screen

For more information read...

https://wiki.unrealengine.com/Logs,_Printing_Messages_To_Yourself_During_Runtime#Related_Tutorial

10:08
  • Use GetOwner() to find the component’s owner
  • *AActor is a pointer to an actor, a new concept
  • Use -> to access methods through pointers
  • Use GetName() to find the object’s name
  • Use %s as a format operator for strings
  • Use * to “dereference” pointers.
Mid Section Quiz
10 questions
07:37
  • Introducing FVector
  • Mixing . and -> to access methods
  • Using multiple format operators
  • Finishing our PositionReport component.
11:45
  • A little more about the editor & temporary actors
  • How to eject yourself from the possessed pawn
  • Snapping objects to the floor (END key)
  • Using the FRotator struct to represent rotation
  • Use SetActorRotation() to rotate objects.
14:27
  • A brief intro of BSP “vs” Static Meshes
  • Use Q, W, E keys to translate, rotate, scale
  • Make good use of grid snapping and quad view
  • Hold ALT + drag translate to duplicate an object
  • Hold L and double-click for temporary work Light
  • This is fiddly, try letting go of L and trying again.
08:38
  • A material is comprised of texture(s) and shader(s)
  • Textures are image files, shaders are GPU code
  • Unreal ships with some impressive examples
  • Unreal has powerful material editing tools
  • Applying materials to our room interior.
09:28
  • A macro is a programmed cut-and-paste
  • This happens before the code is compiled
  • Can unlock powerful functionality
  • We don’t get code complete as standard
  • Can also create really weird build errors
  • Expose ATriggerVolume* to the Details window
10:14
  • A trigger volume is a very versatile tool
  • A 3D volume that detects things entering / leaving
  • We’re going to use one as a pressure plate
  • How we’re going to specify what can open doors
  • Use IsOverlappingActor() on ATriggerVolume
  • Polling vs using events.
10:27
  • We’ve used GetOwner() to search “bottom-up”
  • Now let’s use GetWorld() to search “top-down”
  • Game Mode specifies the Default Pawn Class
  • The Default Pawn is your “body”, is transient
  • The Player Controller is your “mind”, persist
  • PlayerController class has GetPawn()
09:08
  • Collisions volumes are also known as colliders
  • These tell the physics engine what hits what
  • A trigger volume just triggers code
  • A collider actually has physics simulated
  • Exploring how to add collision volumes
  • Prevent players from passing through the door!
11:28
  • Using GetWord()->GetTimeSeconds()
  • Making our game highly “play tunable”
  • Re-factoring our code for simplicity
  • Using a spotlight to provide “affordance”
  • Play-testing to ensure the game is annoying!
05:32
  • We want to be able to lift the chair next
  • We’ll add a Grabber.cpp component to the player
  • The player is a temporary actor, appears on play
  • The Game Mode sets which Default Pawn to use
  • Create Default Pawn & Game Mode Blueprints
  • Specify our modified Default Pawn.
Mid Section Quiz
10 questions
07:28
  • Why Blueprint is helpful in this case
  • How to make a Blueprint from the Default Pawn
  • Note this Blueprint class inherits, an “is a” relation
  • A Blueprint is like a template
  • You make an “instance” in the scene
  • Explore “instantiating” from Blueprint & modifying.
07:05
  • “Hard coding” means assets written into code
  • The DefaultPawn_BP is an asset
  • We want to be able to track changes to its name
  • It is convenient to use Blueprint for this purpose
  • Extending our C++ Game Mode with Blueprint
  • Selecting the new DefaultPawn_BP
12:42
  • Know where the player is looking
  • Out-parameters can be confusing
  • A way of marking-up out parameters
  • Continuously logging player viewpoint.
12:10
  • How to add vectors
  • Calculating our line trace end point
  • Using debug functions for visualisation in Unreal
  • Use DrawDebugLine() to visualise the vectors.
10:15
  • Line tracing (AKA ray casting) is a very useful tool
  • Imagine we shine a virtual laser into the world
  • We can use different view modes to visualise
  • Simulating physics sets the object channel.
12:03
  • Meet references for the first time
  • LineTraceSingle may be deprecated
  • Build params inc. FCollisionQueryParams

05:51
  • How references and pointers compare
  • What the * symbol means in different contexts
  • What the & symbol means in different context
  • How it all hangs together.
06:40
  • What to do if your Unreal solution keeps crashing
  • How to delete all temporary files
  • The order in which to reset things
08:44
  • What FindComponentByClass() does
  • How to use it to find attached components
  • Introducing angle brackets <> for generics
  • Use nullptr to initialise your pointers
  • Log a useful error if the component isn’t attached.
11:30
  • Settings > Project Settings > Engine > Input
  • Action mappings are used for on / off actions
  • Axis mappings are used for analog values
  • You can give players a way or re-mapping
  • Many keys can bind to one action
  • How to call a function on a key press or release
09:25
  • How the arrow, dot and :: accessors work
  • Introducing virtual memory
  • Introducing permanent storage, stack & heap
  • Heap is also known as free store
  • How accessor operators relate to memory
  • Bind another input action
Mid Section Quiz
10 questions
13:50
  • A “hot loop” is code that get called often
  • TickComponent is a good example, every frame
  • Beware of code that you know will be called a lot
  • Make it clear what happens every tick
  • Refactor our code for speed...
  • ...and make it ready for for the physics handle.
12:30
  • Unreal provides a Physics Handle that’s ideal here
  • The Physics Handle component docs are scant*
  • Find an example of its use in the engine
  • Get the physics handle working.
12:25
  • Using multiple getters for multiple return values
  • Less lines of clear code is better (143 at start)
  • Naming is really important, take the time
  • Comment the “why”, don’t assume it’s obvious
  • The “what” should be obvious...
  • … but it can be helpful to add clarification
12:07
  • A TArray is Unreal’s go-to container class
  • Use to contain many elements of same type
  • We’ll use to contain all actors on pressure plate
  • Give our Default Pawn an eye-height and mass
  • Making our pressure-plate based on total mass.
07:41
  • Using auto& as an auto reference type
  • Automatically iterating over a TArray
  • Pattern: for (const auto& Iterator : Array)
  • How to find an actor’s mass
  • Tweaking and testing our mass values.
07:58
  • Are you using source control? If not start now
  • You can “binary search” commits quite fast
  • For example 1024 commits takes max 10 tries!
  • Think “what changed” and “possible side-effects”
  • Remember you can eject with F8 during play.
08:49
  • You may want to re-size objects (e.g. panels)
  • Doing so will stretch the texture
  • You can re-scale a few ways
  • One way is in the material blueprint
  • UV mapping because we ran out of letters!
  • Using the TexCoord node in the material editor.
11:34
  • Horrible crashes when we follow a nullptr
  • We must always check pointers before use
  • When declaring always initialise to nullptr
  • Look for * in your .h files to help find pointers
  • Also check before every use and handle nullptr
  • Sometimes we may chose not to, e.g. Owner.
11:36
  • Sometimes Blueprint’s the better choice
  • For example defining our door swing as a curve
  • We can create an event called OnOpenRequest
  • Using UPROPERTY (BlueprintAssignable)

Students Who Viewed This Course Also Viewed

  • Loading
  • Loading
  • Loading

Instructor Biography

Ben Tristem, Best-selling Instructor, Game Developer, Online Entrepreneur

Hi, I'm Ben. I have a degree in computing from Imperial College London, and a physics diploma from the Open University.

I started working for myself at the age of 15, and never looked back. I explored careers as varied as being a commercial pilot, stunt-man, rock climbing instructor, and more. None of these provided a continued challenge, and stable income in the same way technology does.

After building and selling a home computer support business, I became an angel investor and business mentor here in Cambridge UK. I fell in love with teaching game development through one of my investments, and I now spend all of my time sharing my passion with people like you.

I can't wait to help you experience the fulfilment, and financial freedom, that having a deep understanding of technology brings.

So why not start learning to make games with me and my team now?

See you soon!

Ben

Instructor Biography

Sam Pattuzzi, Software Engineer, University of Cambridge

I wrote my first game when I was 14 and ever since, programming has been a key part of both work and play in my life. I studied Computer Science at the University of Cambridge where I still teach undergraduates. When I'm not teaching, I'm a freelance software engineer and enjoy my work with tech start-ups and social businesses.

For me, Udemy is the opportunity to combine my passions for teaching and programming.

Ready to start learning?
Take This Course