Unreal Engine 4 Blueprints - The Ultimate Developer Course

We download Unreal Engine and explore the Epic Games Launcher. We install the engine and create our first project in Unreal, making use of one of the Unreal Engine template projects.

We look at the different panels in the editor and see how we can use them to make game development easier in the engine.

We learn the different ways to maneuver in the viewport.

We go over the numerous Viewport Icons in the Level Editor and explain what they do.

We finish looking at the viewport icons.

Blueprints function according to a class Hierarchy. We discover just what that means in simple terms so we can better understand how the Blueprint system works and how we can use it.

We begin with Actors and how to create them. We add components and edit their properties.

The root component is a required component all Actors have. We visit this component and see how it works in relation to the Actor and the other components in the Actor.

Default settings show up on the Details Panel for the Blueprint default. Instance settings show up on the Details Panel for individual instances in the world. It's important to know the difference between the two.

BeginPlay events happen at the beginning of the game, when the Actor gets created. We learn how to use them and initialize some logic in the BeginPlay event.

The Tick event is called every frame. This allows us to update our logic continuously during the game.

Overlap Events are essential to all games. We learn how they work and create some of our own.

Casting is a topic necessary for Unreal Engine developers to understand. We learn how we use this concept to cast types from one type to another and how casting fails when an object does not belong to the class to which we are casting.

Particle emitters allow us to create special effects. We learn how to add these to our game.

Scene Components are components with a transform, but they do not have a mesh representation.

The sequence node makes it easy to fire off logic in sequence.

The IsValid node allows you to check if a variable is populated with valid data.

Adding impulse is a great way to send an object flying!

We can check to see if an object is equal to another object with this convenient node.

Hit Events come in handy when developing games. We go into detail on how to use them.

We have some fun building an example level and manipulating some objects!

The Pawn class is derived from Actor. It has some additional capabilities, such as the ability to be possessed by a controller.

When a controller possesses a Pawn, it can now add movement input for the Pawn.

We learn how to configure the Pawn for movement.

Trigger volumes provide an easy way to trigger game logic when objects overlap with them.

Movement mechanics wouldn't be complete without jumping!

We learn how to transition from the current level to a new level while in-game.

Pickups are a common gameplay mechanic and we learn how to implement them using overlap events.

It's a valuable skill to be able to find quality assets for your game. We get some assets into our game project.

Physical Materials allow for you to have some physical properties on object surfaces such as friction.

Damping ensures that an object in motion will slow to a stop.

In the following video, we will be using sounds effects. One of the sound packs is no longer available for free, Retro 8 Bit sounds, so it is not provided, but the Epic Games Marketplace has lots of free sound effects you can use in their Permanently Free collection in the Epic Games launcher. You can download and use any sound assets you like as we learn how to use them in this course.

Playing sounds is an essential part of game development. We learn how to play sounds in-game.

More on Particles!

Widget components provide us with a convenient way to have HUD widgets attached to an Actor.

Unreal Engine has a single, boring font. But we can find and import any font we wish to use in our game!

We learn how to toggle the visibility for our widgets.

We can animate our widgets, and in this video we learn how.

We learn how to bind text so that our HUD text will change according to logic in the game.

Explosives are a fun application of overlap events and concepts from the Pickup class.

We learn about the HUD and how we can use it.

Saving the game is a crucial feature to most video games. We learn how to do it.

We make a button for the ball to press.

We apply our button logic to affect other Actors such as a door.

We apply sound to the door.

We go into detail on adding movement inputs for our pawn.

Every game needs a win condition!

We learn how to quit and pause the game.

We apply our skills to create a booster button to launch the ball into the air!

Wall jumping is a side effect of enabling jumping in the event of a hit. We take care of it here.

We make a generic button that can affect any number of targets.

Interfaces allow you to have a set of functions that can have unique implementation of any class that implements them.

We learn how to use the construction script to affect Actors before the game even starts.

Dynamic materials allow us to change properties on a material at run time in-game.

We apply our knowledge of the construction script to see how we can create a procedural fence.

Collision volumes allow for us to have overlap events that will trigger logic in Blueprints.

We create a progress bar so we can keep track of our progress and report it to the player on the screen.

Event dispatchers allow for another useful form of Blueprint communication.

We package our first game into a playable executable file!

We start our second game project.

We create a ball class that bounces off of surfaces and learn how to do this with the reflection vector.

We create a Paddle class that we can control with the mouse.

We learn how we can course correct with the paddle depending on it's movement.

We create a Brick class that we can damage when it gets hit by the ball.

We implement damage for the Brick class.

We implement lives and the loss of lives when the ball gets lost.

Different states in the game determine what options the player has at the time.

We create a countdown mode to prepare the player for starting the game.

When we lose a ball, we want to let the player know they made a mistake.

We implement a Game Over state.

We implement a state for when a level has been completed.

With the Game Instance class, we can keep information stored between levels, persisting for the entire game session.

We create a Level 2 to open when Level 1 is completed.

We add a Game Complete state.

We get some assets and make a more stunning and beautiful level.

We package our second game!

We create a Top Down project and see how the Top Down mechanics work in the template project.

We create our own new level.

We create a Blueprint for a generic room to make game design easier.

We learn about how Character Animation works in Unreal Engine and implement it for our own Character class.

We implement movement for our Character class.

We see how to implement touch input for mobile devices.

We learn about cameras and switching between them.

We create an icon Widget to indicate the selected player.

We animate our cursor icon.

We distinguish between tapping and dragging our finger on the device and implement different mechanics depending on which we are doing.

We learn how to switch between Characters.