Unfortunately we can't accept Pull Requests as they will not end up in the course.

This is the Unreal Engine Developer course – it started as a runaway success on Kickstarter and has gone on to become one of the bestselling Unreal courses on the internet! Continually updated in response to student suggestions, you will benefit from the fact we have already taught over 360,336 students game development, many shipping commercial games as a result.

You're welcome to download, fork or do whatever else legal with all the files! The real value is in our huge, high-quality online tutorials that accompany this repo. You can check out the course here: Unreal Engine Developer

• Welcome, fresh start, new energy
• Did you go back and modify Building Escape?
• Most ambitious section yet
• Bookmark the live Google Slides
• Comment on the slides, especially typos
• Come say hi at community.gamedev.tv

• The concept of the game
• The rules of the game
• Some of the asset requirements for the game
• Identify possible technical challenges.

• The distinction between Git vs GitHub
• Use Unreal’s toolbar & SourceTree
• Enable Git Large File Support (LFS)
• Setup on GitHub (no readme.md or initial commit)
• Push to GitHub and share
• Warning: may take a while on slow broadband.

• Limitations of Unreal’s connection to GitHub
• How to reset to previous commit to combine
• Presenting your public GitHub page well
• Using Markdown to enrich formatting.

• Upgrading my project to Unreal 4.13
• An overview of the scene
• How the First Person Character is composed
• Adding a spiral staircase.

• Add a third person character to the scene
• Caution about tidying files at this stage
• Add a navmesh, and check it’s continuous.

• Setup a Blueprint AI controller class
• Behaviour Trees controll AI execution flow
• Blackboards hold AI instance data
• How to associate a behaviour tree with an AI
• Testing that our behavior tree is running.

• Blackboard data is like member variables in code
• Using blackboard data to set patrol points
• Practice setting blackboard values in Blueprint
• Test simple AI patrol behaviour.

• Add a variable to the NPC’s blueprint
• How to make a variable an array in blueprint
• Introducing Target Point actors
• Using target points to specify patrol routes.

• Actors are more general than target points
• How to select an actor from another actor
• Getting the AI Controller to set Blackboard data
• Testing our characters go to a set waypoint.

• Use layers (usually used for visibility)
• Use groups as a simple multi-select tool
• Use tags, can be flexible but easy to forget
• Use a parent Empty Actor, or a Folder
• Group on game object (e.g. array on NPC)
• The key is to know the pros and cons.

• How to use Blackboard Key Selector variables
• Creating new Tasks in Behaviour Trees
• Pseudocode programming in Blueprint
• How to use the Execute AI node
• How to use the Finish Execute node.

• The first rule of performance: “profile first”
• Access profiler from Window > Developer Tools
• Choose Session Front End
• Select your running game session
• Chose Profiler tab, and hit Data Preview
• Search for your function and double-click.

• Add “AIModule” and “GameplayTasks” to build
• Inherit C++ class from UBTTaskNode
• Override ExecuteTask()
• Return EBTNodeResult::Succeeded;
• Don’t try and extend in Blueprint
• Use Blueprint XOR C++ for a given task.

• Expose a blackboard key selector in C++
• #include “BehaviorTree/BlackboardComponent.h”
• OwnerComp.GetBlackboardComponent()
• Use GetValueAsInt() etc to get the value
• You can now access blackboard data in C++.

• We have coupled our AI ChoseNextWaypoint task to the Third Person Character.
• We have also specialised our Blueprint class with a variable, PatrolPoints.
• These dependencies are undesirable, but we will proceed with our conversion.

• OwnerComp.GetAIOwner() to get AI Controller
• If you’re casting, you’re probably coupling
• Use .Num() to get number of elements in TArray
• Use TODO for reminders, to help you FOCUS
• FOCUS = Follow One Course Until Successful.

• We created PatrollingGuard by inheritance
• How about if we want a patrolling tank?
• Another option is to use an actor component
• This is an age-old debate
• Let’s get some real-world experience of the two
• Convert to a component model.

• What we've covered recently
• What's coming up.

• Yes it should be easier than this, tell Epic!
• How to remove CPP files from browser in Unreal
• The process for deleting C++ classes.

• Also called Material Instances
• These allow modification with little overhead
• How to create an instanced material.

• Use AI Perception, it’s newer than Pawn Sensing
• How to add AI Perception to your controller
• Use the apostrophe key ‘ to enable AI debug
• Remember Shift + F1, F8, F11 etc.

• Use the On Target Perception Updated event
• This reports the actor sensed
• And the class of the sense (e.g. sight, hearing)
• How to setup perception events.

• Hearing is a sense that compliments sight
• How to set up AI Perception hearing sense
• How to get hearing perception to trigger
• Making your actor create a noise.

• The skeleton comprises the bones
• Over the skeleton lays a skeletal mesh
• Each vertex of the mesh connects to bone(s)
• The animation tells the bones how to move
• The bones tell the mesh how to move
• The Animation BP controls the animations.

• How to change a mesh’s animation class
• Matching the animation’s mesh to…
• … the mesh selected on the character
• You can apply instance changes to blueprint
• However be careful what you take with you
• Solving “can’t save… graph is linked” error.

• You can start with a off-the-shelf blueprint
• We can then add our reusable components
• Another way of getting our desired character.

• Behaviour trees can get complex
• We want to keep a consistent level of abstraction
• Behaviour trees can run “sub” trees
• This helps us organise our project.

• Congratulations on getting this far in the course.
• Recapping the AI work we have done so far.
• Introducing the new instructor for the section: Sam.

• Why refactoring is so important.
• Refactor skills give you the edge.
• What’s coming up in the next lectures.

• Deleting and Moving folders.
• Ensuring deletion on the file-system.
• Good file structure for Unreal.
• Viewing the dependencies of an object.
• How and when to fix redirectors.

• Renaming CPP files.
• How to deal with renaming blueprint parents.
• Refactor class names in CPP.
• Updating .generated.h files.

• Repeating the renaming process.
• Finishing our refactor.
• Fixing CDO Constructor errors.

• Reading existing source code for hints.
• Creating a socket on a skeletal mesh.
• Parenting a gun to that socket.
• Removing unused assets.

• The major components.
• How to preview animations.
• Definition of an animation and pose.
• Understanding the AnimGraph.
• Playing a custom animation.

• Why state machines?
• What are state machines?
• What’s inside a UE4 state?
• How to add transitions.
• Adding a shooting state.

• What is a blend space?
• How to create a movement blend space.
• Examining the existing Jog blend space.
• Replicating for Ironsights.

• Creating an offset animation.
• Applying an offset to a base.
• Conditional blend nodes.

• Aim offset assets.
• 1D vs 2D Aim offsets.
• Editing an existing animation sequence.

• Revising Behaviour Tree tasks.
• Making our character face us.
• Using AIController’s SetFocalPoint()

• More code reading.
• Jumping between files in Visual Studio.
• Difference between movement and rotation.
• Mapping out complex systems.

• Getting the control rotation.
• Focus Actor vs Focal Point
• Splitting rotators and setting pitch.
• Controlling Animation BP properties.

• Creating a decorator.
• Sequence vs Select nodes.
• Aborting decorators early.
• Clearing blackboard keys from blueprint.
• Patrolling, agro and following.

• Using decorators vs services.
• Creating a service.
• Deeper into behaviour tree states.
• How to implement suspicion.
• Giving our character breathing space.
• Comparing BP Validity and NULL.

• Preventing Behaviour Tree flicker.
• Creating mutually exclusive states.

• Viewing behaviour while playing.
• Using tags on Actors.
• Revising interrupting tasks.
• Adding in multiple actors.

• Create a Gun actor.
• Move the firing code over.
• Revising refactoring.

• Revise spawning child actors.
• Attaching actors to sub-components.
• Attachment rule to sockets.

• Playing montage animations.
• Connecting to actors in code.
• Finishing our refactor.

• The pros and cons of LFS.
• How to move files from LFS.
• Tracking folder instead of extensions.
• Where tracking happens.

• The pros and cons of LFS.
• Organising your project for clarity.
• How to deal with .umap assets.

• Previewing the gun with the skeleton.
• Positioning the gun.
• Child actors with Blueprint.
• Using Child Actor Components.

• Local vs component-space poses.
• Understanding bone-space.
• The principles of IK.
• End effectors and Joint targets.
• Mapping to the Two Bone IK node.

• Using the Two Bone IK node.
• Effectors vs Joint targets

• Using UE4 built-in version control.
• Diffing blueprints.
• LFS vs Git assets in editor.

• Boolean blending in Unreal.
• Setting variables in animation BP.
• Making the AI aim.

• When to use additive identities.
• Blending additive animations.
• Creating an additive firing animation.
• Controlling firing from the AI.

• Synchronising sound and animation.
• Creating custom notify events.
• Hooking up our gun trigger to AI.

• Applying damage from a projectile.
• Taking damage in a BP character.
• Detaching a controller from a Pawn.

• Revision of BP refactoring.
• Making our Animation BP clean.
• Death animations on the AI.

• Swapping out a 1st to 3rd person character.
• Wrapping rotations.

• Own See vs Owner no see meshes.
• Why 1st person Meshes.
• Hooking up Fire input in TPCharacter.

• Why we need two gun meshes.
• Creating Blueprint components.
• Scene components vs Actor components.
• Camera rotation with control rotation.

• Local vs Global rotation.
• UE4 optimizations for unpossesed characters.

• Using the Arrow component.
• How to architect an infinite runner.
• Overview of how we want our levels to work.

• GameMode BP vs Level BP
• Creating a blueprint GameMode
• How to spawn tiled terrain.
• Using a blueprint for-loop.

• Why we need level gating.
• Our approach to gating.
• Enabling/disabling collisions.

• Creating material instances.
• Exposing material parameters.
• Swapping materials in blueprint.
• Adding affordance to our barriers.

• When to delete previous tiles.
• How to get hold of the Game Mode.
• Spawning new tiles when needed.
• Keeping the minimal tiles in memory.

• Fix camera glitch while strafing.
• Merge the NPC and Player folders.
• Revise redirectors.
• Revise folder movement and deletion.

• Debug a projectile spawn issue.
• Overview the collision system.
• Understand hit and overlap notifications.
• Review different Collision Presets

• NavMesh and procedural terrain.
• Dynamic NavMesh generation.
• When LFS shouldn’t be used.

• Make the player tough for testing.
• Deeply understand the AI system.
• When is code too complex to debug?
• Write high level pseudo code.

• Parallel actions in Behaviour Trees.
• Pseudocode-lead refactoring.
• Aborting lower priority with decorators.
• Organising conditional Behaviour Trees.

• Implementing a conditional decorator.
• Custom task nodes.
• Clean up when task node is aborted.

• Updating to 4.15.0
• Storing build data outside of .umaps.

• Renaming to style guide
• Problems of our existing architecture
• Improved gun-centric architecture
• Challenge: reinstating the gun actor.

• Creating and reparenting a character
• Challenge: Converting the component hierarchy
• Reviewing my Mannequin.cpp

• Reviewing the architecture
• Revision: binding input in C++
• Challenge
• Remove firing from Animation BP
• Control trigger from AI

• How cooldown nodes work.
• Adding gameplay tags.
• Challenge: Let the AI Cooldown
• Randomised burst of fire.
• Separated into sub-behaviour trees.

• What is an animation slot?
• How to blend by root bone.
• "Caching" a pose.
• Challenge: Create and Play Firing Montage

• Attach gun to correct mesh if player
• Reattach gun when player dies
• Challenge: Play Two Montages

• Importing asset pack.
• Introduction to procedural terrain.
• Creating ground mesh from BSP.
• Challenge: creating spawnable props.

• Create a Tile C++ class.
• Expose a UFunction to spawn actors.
• Functions to generate random data.
• Challenge: generate a random spawn point.

• Spawn an actor.
• Randomise the number of actors.
• Challenge: place the actors correctly.

• What is a Sweep?
• How to Sphere Cast in C++.
• Challenge: visualise the cast.

• Creating a Trace Channel.
• Where to configure presets.
• Challenge: make it trace green.

• Writing an actor spawning algorithm.
• Challenge: generate empty space.
• Converting from local to global positions.

• Adding randomised rotation.
• Challenge: add randomised scale.
• Tweaking the spawn radii.

• Flyweight pattern for rendering
• Adding LOD for foliage.
• Challenge: spawn grass instances.
• Reviewing my code.
• Configuring my component.

• Outline of EQS.
• Enabling EQS.
• Creating and testing queries.
• CHALLENGE: Create a Waypoint Query.

• Overviewing the navigation issue.
• Getting hold of existing objects.
• CHALLENGE: Finding NavMeshBoundsVolumes

• Actor Pool architecture.
• Creating the Actor Pool Component.
• CHALLENGE: Plumb the Pool.

• Using the Checkout API
• Overview of object lifecycle
• CHALLENGE: Return to Pool
• Populate the initial pool.

• Implementing checkout.
• Challenge: Implement return and add.

• Rebuilding the Navigation.
• Offset the NavMeshBoundsVolumes.
• CHALLENGE: Spawn on destroy.

• The AI spawning problem.
• Combining parameters as structs.
• CHALLENGE: SpawnPosition Generator Function.

• How to spawn AI.
• PlaceAIPawns definition.
• CHALLENGE: spawn AI in the world.

• Adding a GameMode Score.
• CHALLENGE: Notify on Tile Conquered

• What is a template.
• When would you use one?
• What is the syntax for functions.

• When copy and paste isn’t enough.
• How to handle tricky types.

• Fixing out spawn issue.
• When static polymorphism isn't enough.
• How to use templates in classes.
• Caveats to using templates in C++

• Extending the HUD class
• Why use the HUD class
• CHALLENGE: Create the scoring UI

• Adding PostProcessing Effects
• CHALLENGE: Ease in on Damage

• Sharing your game
• CHALLENGE: Recruit Some Testers
• Changing the lighting
• Firing lasers
• Improving score UI
• Shorter blackout effect

• Making death easier
• How the camera works
• Overview of SetViewTargetWithBlend
• CHALLENGE: Smooth Blend the Camera

• Unpossing with View Targets
• Auto managed View Targets
• CHALLENGE: Manually Manage the View Target

• Peace before the storm
• CHALLENGE 1: Fix the crashing issue
• CHALLENGE 2: Make the Actors spawn
• Parametrise the enemy count
• BONUS: Fixing multiple camera transitions

• WELL DONE, over 50h of content
• You've got a great understanding of Unreal
• Your C++ knowledge is transferrable
• Improve with: more weapons, pick-ups, progression
• Please share screenshots / 20s video with community.