Unreal Engine C++ Developer: Learn C++ and Make Video Games
- Polish [Auto-generated]
- Portuguese [Auto-generated]
- Spanish [Auto-generated]
- 48.5 hours on-demand video
- 17 articles
- 16 downloadable resources
- Full lifetime access
- Access on mobile and TV
- Certificate of Completion
Get your team access to 4,000+ top Udemy courses anytime, anywhere.
Try Udemy for Business- C++, the games industry standard language.
- How to use the Unreal Engine 4 Editor.
- Git as a version control and backup system.
- Object Oriented Programming and how to put it into practice.
- Sound effects and audio to add depth to your games.
- Game design principles.
- Programming patterns and best practices.
- Unreal's Terrain Editor to create epic landscapes.
- Artificial Intelligence behaviour programming for enemies.
- Strong and transferable problem solving skills.
- Modern game development technologies and techniques.
- A fundamental understanding of computers.
- Write code that is clean and to understand.
- Unreal Gameplay Framework to make games easily.
- Advanced vehicle physics.
- Blackboard and Behaviour Tree for customizable AI.
- Animation Blueprint for custom character animation.
- C++ template programming to reduce repetition.
- Vector maths for game play and physics calculations.
In this video (objectives)…
1. Meet the team.
2. Learn about our community.
3. Engage in at least one community.
4. How to ask good questions.
After watching (learning outcomes)…
You will know where to find help when you need it.
(Unique Video Reference: 1_I2_UC2)
In this video (objectives)…
Unreal Development Environment overview.
Mac users skip or skim rest of video.
Already got VS Community 2019? Skip or skim video.
We're installing VS Community so we can code in C++.
Easiest way to ensure we have all the pre-requisites.
Choose package including Epic Games Launcher.
We'll ALSO install VS Code later as lightweight option.
After watching (learning outcomes)…
You will have Visual Studio Community 2019 installed if on PC.
(Unique Video Reference: 2_I2_UC2)
In this video (objectives)…
Remind PC & Linux users to skip.
MacOS 10.14 Mojave or later required.
Remind we're installing for pre-requisites.
Start Xcode downloading.
Install Epic Games Installer.
After watching (learning outcomes)…
You'll be ready to download and install Unreal Engine.
(Unique Video Reference: 3_I2_UC2)
In this video (objectives)…
sudo apt install g++ git make -y
git clone --single-branch --branch 4.22 https://github.com/EpicGames/UnrealEngine.git
Create GitHub “Personal Access Token” with “repo” access (or use SSH)
cd UnrealEngine
./Setup.sh (register Unreal file types when asked)
./GenerateProjectFiles.sh (much faster)
make will take some time (add -j x to set x jobs). Have 100GB+ free.
cd Engine/Binaries/Linux/ then run ./UE4Editor Celebrate!
Vulkan warning? Update or ./UE4Editor -opengl
Write-down start time & share build-time & specs with community!
After watching (learning outcomes)…
You will be able to build Unreal Engine from source (on Linux at least).
(Unique Video Reference: 4_I2_UC2)
In this video (objectives)…
Why we're also using VS Code
Install Visual Studio Code
Extra note on how to open Code on Windows.
After watching (learning outcomes)…
Install VS Code, and open it from the Developer Command Prompt on Windows so that we can compile C++ on the Terminal.
(Unique Video Reference: 6_I2_UC2)
In this video (objectives)…
I’m excited that you’re all set-up and ready go
Be using Unreal in section 3 for first time, with Mikey
Why Ben designed the course this way
Why Gavin’s only in Section 2
Remember to use our community forum, Discord, and Facebook group
Thanks for being our student, enjoy the journey.
After watching (learning outcomes)…
You will know where to get support, and be ready for the next section.
(Unique Video Reference: 7_I2_UC2)
In this video (objectives)…
+ Handing over to Gavin
+ Why a terminal game first
+ Following in VS Community 2019
+ Beware of the trap of CIN etc.
+ Will set you up for Bull Cow in Unreal next
+ Enjoy the section!
After watching (learning outcomes)…
Feel ready to dive into your first C++ program.
(Unique Video Reference: 0_TX_UC2)
In this video (objectives)…
+ Understand the gameplay of Triple X, the game you will be building in this section.
+ Why learn C++
+ Start thinking about a theme for your own version of Triple X
After watching (learning outcomes)…
Understand the gameplay behind Triple X
Unique Video Reference: 1_TX_UC2
In this video (objectives)…
+ Understand the lines of code that are expression statements in your file
+ Understand the lines of code that are declaration statements in your file
+ Commenting code
After watching (learning outcomes)…
Understand how to comment your code
Unique Video Reference: 7_TX_UC2
In this video (objectives)…
Understand the game we are going to create.
It’s a terminal game, but within Unreal.
Allows us to use Unreal specific C++.
How Does The Game Work?
Word guessing game.
Guess the Isogram...
Letter in guess and right place is a “Bull”.
Letter in guess, but wrong place is a “Cow”.
Mechanics Of The Game
Hidden word pulled from a list.
Game will let us know the number of lives we have.
Player will make a guess.
Lose a life if you get it wrong.
Display how many bulls and cows.
If the correct word is guessed then the game is won.
If the lives run out, the game is over.
After watching (learning outcomes)…
You will know what is coming up in this section.
(Unique Video Reference: 1_BC_UC2)
In this video (objectives)…
Create multiple viewports.
Use LMB RMB and MMB to navigate.
User RMB and WASD, EQ to move around the level and the scroll wheel adjusts the speed.
After watching (learning outcomes)…
You should be comfortable moving around within a level.
(Unique Video Reference: 5_BC_UC2)
In this video (objectives)…
Any object that can be placed in your level is called an Actor.
They all have a transform.
There are several different types of Actor.
After watching (learning outcomes)…
You will be able to edit your levels actors.
(Unique Video Reference: 6_BC_UC2)
In this video (objectives)…
An Actor is a container that can have many components.
There are many different component types.
We have a special component called the “BullCowCartridge”.
After watching (learning outcomes)…
You will have attached the component that will allow your in-game terminal work!
(Unique Video Reference: 10_BC_UC2)
In this video (objectives)…
std::cout << “Welcome”;
string Word = “Welcome”;
For strings we need to use FString instead.
Later on instead of int, we will use int32.
After watching (learning outcomes)…
You will start to understand that Unreal uses its own types.
(Unique Video Reference: 12_BC_UC2)
In this video (objectives)…
Process the player will go through.
There will usually be many loops with in a larger game.
What is our player’s experience from the moment they interact with the terminal.
After watching (learning outcomes)…
You will understand the purpose of creating a visual game loop to check your code against
(Unique Video Reference: 14_BC_UC2)
In this video (objectives)…
We will cover classes in more detail later on.
HiddenWord needs to be used across multiple functions in the BullCowCartridge Class.
“BCC” Class creates an instance of “BCC”.
HiddenWord can then be used across that instance.
After watching (learning outcomes)…
You will understand why you need to declare instance variables in the header file.
(Unique Video Reference: 17_BC_UC2)
In this video (objectives)…
Sam and Michael go through the step necessary to fix slow compile times.
Now your compile times will be quicker when not changing the header file.
After watching (learning outcomes)…
You will know the steps you need to take to fix slower than necessary complaining times in UE4.
(Unique Video Reference: 18_BC_UC2)
In this video (objectives)…
You will understand the importance of pseudo coding
Complements the flowchart approach really well.
Allow you to put down ideas, and keep track of progress.
Easier to catch logical errors early.
Detailed, easy to read template for the rest of our code.
After watching (learning outcomes)…
You will be comfortable writing your own pseudo code
(Unique Video Reference: 20_BC_UC2)
In this video (objectives)…
Functions work best when they something specific.
The name of the function tells us what it does.
If you are having trouble naming your functions it might be doing too much.
void UBullCowCartridge::InitGame()
After watching (learning outcomes)…
You will be able to create basic functions in Unreal Engine 4.
(Unique Video Reference: 21_BC_UC2)
In this video (objectives)…
How to search for code in a single file.
How to replace single words.
How to replace all instances of that search.
Replacing across multiple files
After watching (learning outcomes)…
You will be able to find anything in your code base and modify multiple instances.
(Unique Video Reference: 22_BC_UC2)
In this video (objectives)…
You will understand that in order to format FStrings correctly your will have to call FString::Printf().
You will be able to include data in your FStings.
Printf() is a static function.
After watching (learning outcomes)…
You will be able to include other data withing Fstrings you are using
(Unique Video Reference: 24_BC_UC2)
In this video (objectives)…
Nothing checking whether the game is won.
Boolean variables in Unreal a prefixed with a “b”.
Example: bool bGameOver.
Actually takes up 1 bit of memory but since memory is only accessed in bytes 1 byte is used.
After watching (learning outcomes)…
You will be able to code and use booleans in Unreal.
(Unique Video Reference: 24 Formatting FStrings)
In this video (objectives)…
You will learn more detail about pre and post increment decrement operators
How they differ from each other.
You will likely use pre increments and decrements.
After watching (learning outcomes)…
You will be able to use pre vs post increments / decrements with ease.
(Unique Video Reference: 26_BC_UC2)
In this video (objectives)…
They are often used interchangeably.
Parameters are used when defining a function.
Arguments are the actual values used in the function when called.
After watching (learning outcomes)…
You will know the difference between parameters and arguments and also understand that the term is often used interchangeably
(Unique Video Reference: 27_BC_UC2)
In this video (objectives)…
We will learn about early returns.
This will make our code more readable.
After watching (learning outcomes)…
You will understand how to leave a function call early once a condition has been met, making your code cleaner and easier to read.
(Unique Video Reference: 28_BC_UC2)
In this video (objectives)…
Strings are an array of characters.
E.g. FString HiddenWord = TEXT(“cakes”);
Array length would be [5], you start from[0]! {‘c’,‘a’,‘k’,‘e’,‘s’,‘/0’}
HiddenWord[3] is “e”
HiddenWord[5 or greater] will crash Unreal.
After watching (learning outcomes)…
You will be able to access the characters on an FString
(Unique Video Reference: 29_BC_UC2
In this video (objectives)…
By using const you protect yourself.
If a function doesn’t change any member variables of the class, make it const.
Makes sure your functions aren’t modifying your classes when you don't intend them too.
Also referred to as a “const function”.
After watching (learning outcomes)…
You will know when to make a function a const member function
(Unique Video Reference: 30_BC_UC2
In this video (objectives)…
When you see/use * next to a type.
Pointers are a memory address.
Like references, they save having to copy/move data in memory.
You can point to any object.
You can lose control of your data.
After watching (learning outcomes)…
You will have an overview of pointers
(Unique Video Reference: 5_BE_UC2)
In this video (objectives)…
You will understand Unreal's class system
You will get an understanding of when you might use a component.
Understand how to create a custom component.
After watching (learning outcomes)…
You will be able to create your own custom components.
(Unique Video Reference: 6_BE_UC2)
In this video (objectives)…
You will understand the pitfalls of hardcoding again, and understand why we really need the relative rotation of the door as our starting point.
After watching (learning outcomes)…
You will have a door component that will open any door to 90 Deg.
(Unique Video Reference: 20_BE_UC2)
In this video (objectives)…
You will expose the TargetYaw parameter to the editor window.
After watching (learning outcomes)…
You will be able to expose parameters you wish to edit to the component so you can adjust values in the engine.
(Unique Video Reference: 21_BE_UC2)
In this video (objectives)…
Use DeltaTime to make the doors movement framerate independent.
After watching (learning outcomes)…
You will realise that not using DeltaTime will change the speed of which things move depending on a frame rate!
(Unique Video Reference: 23_BE_UC2)
In this video (objectives)…
1. Creating a Blueprint Default Pawn that can have the Grabber component attached to it.
After watching (learning outcomes)…
You will be able to create a Blueprint that inherits from the DefaultPawn.
(Unique Video Reference: https://community.gamedev.tv/tags/32_be_uc2)
In this video (objectives)…
1. Inherit a new BluiePrint GameMode from the C++ GameMode.
After watching (learning outcomes)…
You will be able to change the GameMode to use the newly created BP version and hence assign the Defaultpawn to our BP version as well.
(Unique Video Reference: 33_BE_UC2)
In this video (objectives)…
How to add vectors.
Calculating our line trace end point.
Using debug functions for visualisation in Unreal.
Use DrawDebugLine() to visualise the vectors.
After watching (learning outcomes)…
You will have drawn a debug line visualising the players reach in the game.
(Unique Video Reference: 35_BE_UC2)
In this video (objectives)…
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.
After watching (learning outcomes)…
You will have set up your scene ready to interact with and have looked through the eyes of the collision engine.
(Unique Video Reference: 36_BE_UC2)
In this video (objectives)…
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.
After watching (learning outcomes)…
You will be able to link from your Grabber class to another component on the same Actor.
(Unique Video Reference: 38_BE_UC2)
In this video (objectives)…
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.
After watching (learning outcomes)…
You will have mapped a key or button on a controller to call a function.
(Unique Video Reference: 39_BE_UC2)
In this video (objectives)…
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.
After watching (learning outcomes)…
You Will know much more about how memory is allocated and have bound a second function call to when the "Grab" Key is released.
(Unique Video Reference: 40_BE_UC2)
In this video (objectives)…
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.
After watching (learning outcomes)…
You Will know much more about how memory is allocated and have bound a second function call to when the "Grab" Key is released.
(Unique Video Reference: 41_BE_UC2)
In this video (objectives)…
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.
Useful Links
Unreal Engine API Reference - UPhysicsHandleComponent.
After watching (learning outcomes)…
You will be able to pick up objects in your game!
(Unique Video Reference: 42_BE_UC2)
In this video (objectives)…
Using multiple getters for multiple return values.
Fewer 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.
After watching (learning outcomes)…
You will have a more streamlined code base.
(Unique Video Reference: 43_BE_UC2)
In this video (objectives)…
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.
After watching (learning outcomes)…
You will have a working pressure plate by adding up the masses of actors in the collision volume.
(Unique Video Reference: 44_BE_UC2)
In this video (objectives)…
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.
After watching (learning outcomes)…
You will understand fully the importance of protecting pointers and will have protected and written error logs to protect and inform you of potential issues
(Unique Video Reference: 45_BE_UC2)
In this video (objectives)…
We’re going to trigger a simple sound in Blueprint.
Later in the course we’ll use C++ too.
However we’ll always reference our assets via BP.
How to trigger a 3D sound.
After watching (learning outcomes)…
You will have sound when the door(s) open and close.
(Unique Video Reference: 46_BE_UC2)
- 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
(Unique Video Reference: 6_BE_URC)
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.
(Unique Video Reference: 6b_BE_URC)
- 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.
(Unique Video Reference: 9_BE_URC)
- 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.
(Unique Video Reference: 12_BE_URC)
- 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
(Unique Video Reference: 14_BE_URC)
- 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.
(Unique Video Reference: 15_BE_URC)
- 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()
(Unique Video Reference: 16_BE_URC)
- 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!
(Unique Video Reference: 17_BE_URC)
- 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.
(Unique Video Reference: 19_BE_URC)
- 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.
(Unique Video Reference: 20_BE_URC)
- “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
(Unique Video Reference: 21_BE_URC)
- 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
(Unique Video Reference: 29_BE_URC)
- 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.
(Unique Video Reference: 31_BE_URC)
- 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
(Unique Video Reference: 33_BE_URC)
- 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.
(Unique Video Reference: 38_BE_URC)
- Unreal’s tools are setup for photoreal landscapes
- Once you set the bar high, the rest must match
- An alternative is to opt for a low-poly look...
- ...then you can focus on gameplay, story, sound
- Can be a good choice for smaller teams
- How to make low-poly, flat-shaded landscapes.
(Unique Video Reference: 9_BT_URC)
Based on where you are in the course, we're going to assume you’re already familiar with the Blueprint tools for UMG (Unreal's UI framework). These are definitely the best way to go about designing your interfaces. Who wants to be doing that in C++!
But there are good reasons to be using C++ for the logic driving your UI: version-ability, performance or just preference. How can we seamlessly bind our clean, performant C++ to the beautiful UI design created by the editor?
This post outlines the tips and tricks Sam has learnt, including...
- Basic setup
- Creating a Blueprint Widget from C++
- Widget Setup
- Getting to your Blueprint widgets
- Binding callbacks
- More cool UI stuff…
Read the full post: https://blog.gamedev.tv/creating-unreal-engine-ui-with-umg-and-c/
Enjoy!
Ben & Sam
- Out parameters smell a little but are used a lot
- Allows you to return a bool and a FVector
- Alternative architecture would be a struct or class
- We’ll do it this way to get you more comfortable with creating your own methods using out parameters.
(Unique Video Reference: 26_BT_URC)
- If we #include in a .h file we create a “chain”
- Any .h file that includes us will in-turn include
- This can be hard to keep track of
- To simply use a type, we can “forward declare”
- Simply put class ClassName; under the includes
- You’ll still need to #include in the .cpp to use.
(Unique Video Reference: 36_BT_URC)
- If something’s weird break it down
- Use logs or the debugger to follow each step
- SuggestProjectileVelocity() has a bug*
- … it MUST have an optional parameter!?
- Moving to forward declarations.
Useful Links
- * UE4 Answer Hub - SuggestProjectileVelocity() Behaving Badly
(Unique Video Reference: 41_BT_URC)
This mid-section challenge will help you integrate your knowledge and really cement what you’ve done in the past few lectures. It will also give you a great foundation of practical understanding on which to build. Please give it a good shot before watching my solution.
(Unique Video Reference: 43_BT_URC)
- You can assign a physics material under collision
- Friction is combined between two surfaces
- The coefficient is the proportion of the contact force that can be exerted sideways before slip.
- Adjust friction and driving forces to get movement.
(Unique Video Reference: 55_BT_URC)
- Bind some input for forward and backward
- Make the method BlueprintCallable
- Make TankMovementComponent a default on tank
- Make a protected tank variable to store pointer
- Make this pointer BlueprintReadOnly pointer
- Test that you get a log of +/-1.
(Unique Video Reference: 57_BT_URC)
- Actor components require instance references
- We were passing these references from the tank
- But we could equally keep them locally
- Move to composing our actor in Blueprint
- Create an initialise method for aiming
- Test it works and hail the simpler code.
(Unique Video Reference: 58_BT_URC)
- We have access to Unreal’s source code
- Let’s look into the UNavMovementComponent.h
- We’re looking for RequestDirectMove()
- We’ll override it without calling Super
- We can then get the golden MoveVelocity vector
- AI tanks can now use our fly-by-wire controls!
(Unique Video Reference: 61_BT_URC)
- Remember “what’s the least fun thing about this?”
- One thing is not knowing if you can fire
- How to change crosshair colour in blueprint…
- … according to the aiming component state
- States: Locked, Aiming, Reloading
- Referencing actor component from player UI.
(Unique Video Reference: 65_BT_URC)
- Move away from CreateDefaultSubObject()
- Make aiming a BlueprintSpawanableComponent
- Get our code re-compiling as soon as possible
- Experience hard crash and add pointer protection
- Possibly get exasperated that we can’t find the suspected null-pointer causing the crash.
(Unique Video Reference: 67_BT_URC)
- Adding log entries to C++ and BP helps you to uncover the timing over events in the engine
- We’re doing this to discover exactly when Construct and Begin Play gets called in both C++ and Blueprint
- Note dropped actors are constructed in editor.
(Unique Video Reference: 69_BT_URC)
- We want to expose a C++ function to Blueprint
- We also want to pass a parameter (aiming ref.)
- Multicast delegates only work like this for actors
- We’re using a component so we use…
- UFUNCTION(BlueprintImplementableEvent)
- You don’t need to define the function!
(Unique Video Reference: 71_BT_URC)
- Actor Components use TickComponent not Tick
- You can find the signature in docs online
- Or by copying from the engine code
- Remember to use override at to check
- Remember to set the boolean in the constructor
- GetWorld()->GetTimeSeconds() alternative.
(Unique Video Reference: 78_BT_URC)
- We can apply a sideways correction force
- Remember Force = Mass * Acceleration
- … and Acceleration = Speed / Time
- So we calculate the force using the slippage speed,the frame time, and the tank mass
- A way to calculate is FVector::DotProduct()
(Unique Video Reference: 80_BT_URC)
- Currently we .gitignore the Starter Content
- Therefore we can’t track changes
- We want a consistent starting point for particles
- So we’re going to delete Starter Content
- Lots depends on it so we use a special tool
- That special tool is the reference viewer.
(Unique Video Reference: 87_BT_URC)
- Unreal has an actor damage system
- We’ll apply radial damage from the projectile
- Then the AActor::TakeDamage() method will be called on the tank (and all other actors in radius)
- We’ll then finish our damage system off
- Solve the int or float damage question.
(Unique Video Reference: 94_BT_URC)
- We’re nearing the end of the section
- You have several challenges over to try
- These include various fixes and improvements...
- Use StartSpectatingOnly() in Player Controller
- DetachFromControllerPendingDestroy() in AI
- Fixing a bug with our starting health
(Unique Video Reference: 97_BT_URC)
- Our player controller line traces to aim
- This can hit the UI in some circumstances
- Change our line trace channel to ECC::Camera
- Add a 1st person camera
- Use the Toggle Visibility Blueprint node
- Bind input and enjoy simple camera swapping.
(Unique Video Reference: 100_BT_URC)
In this video (objectives)…
- Introduce the physics constraint component.
- Combine two components with a constraint.
- Tweak the limits of a constraint.
After watching (learning outcomes)…
Create a physics constraint between two components and set limits.
(Unique Video Reference: 103_BT_URC)
In this video (objectives)…
Chaining constraints together.
Setup the new Axle and its contraint.
Why we need a collider to simulate physics.
Using USphereComponents.
Disabling collisions on the Axle.
Constraining the wheel rotation.
After watching (learning outcomes)…
How to chain constraints together.
In this video (objectives)…
Exposing AddDrivingForce().
The requirements for GetWheels().
Update DriveTrack() to apply for all wheels.
Remove OnHit() and ApplySidewaysForce().
How to iterate over child components.
After watching (learning outcomes)…
Iterate over child components.
In this video (objectives)…
Detecting no collision.
Understanding Tick Groups and their order.
When does OnHit get called?
Apply force on collision or reset.
After watching (learning outcomes)…
An understanding of the Tick Group Order and how it interacts with physics notifications.
Congratulations on completing the course, that's no mean feat! So what now?
+ If you're looking to continue to your Unreal journey then check out our Unreal Multiplayer Mastery course.
+ If you’d like to learn C#, another C family language, then head over to our Complete Unity Developer 2.0 course.
+ If you're looking to create assets for your games, then our Blender course is for you.
Look forward to seeing you there soon.
- 64-bit PC capable of running Unreal 4 (recommended).
- Or a Mac running MacOS 10.14 Mojave or higher
- About 15GB of free disc space.
This "critically-acclaimed" and "insanely successful" Unreal Engine course was created in collaboration with Epic Games.
*NEW* Every section of the course is being fully updated and remastered to Unreal Engine 4.22+. The first three remastered sections have been released! New content will be released over the coming weeks and months. Existing students get all the new material for free.
The course now has high-quality handwritten subtitles throughout, available as closed captions so you can turn them on or off at your convenience. This is one of the best Unreal Engine tutorials on the web.
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, 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 can be a complex beast to get into, but we break it down step-by-step
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.
We start super simple so you need no prior experience of Unreal or coding! 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.
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.
Multiplayer features.
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 to learn Unreal C++ now, you won't be disappointed!
All future content updates are included free!
- 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.
