This is a brief explanation of what blueprints are and how they can be used.

In this lesson we will go though the different ways to create blueprints as well as how to navigate the blueprint editor UI.

In this lesson we will go though how nodes are run in blueprints and the general layout of how we setup blueprints code chains.

Here we will learn what a variable is and what their used for in game development.

Booleans (Or bool for shot) are variables that store a true or false value, in this lesson we take a look at how to use them and some of the nodes most commonly used with Booleans.

Name, Text and String variables are different types of variable that store text values, each has a different purpose and we will cover those in this lesson.

Vectors, Rotators and Transforms are used to specify something position in 3D space. In this lesson we will cover how to use these values and some of the functions that use them.

Actors and object reference variables are how we specific which object in the world we effect. If you want to move a cube but you have 100 cubes in your level you need to have an actor variable that stores a references to the specific cube that you want to move. In this lesson we will go into detail about how this works and how to use the built in nodes that can be used with actor and object reference variables.

Array variables are a way of store multiple variable values in a single variables node. They allow use to then go though all the values stored in them to retrieve that information. In this video we will cover how to create an array using any variable type and how to loop though the values it stores.

Functions are used to create reusable self contained pieces of code that can be changed once to effect all the instances of the function. In this lesson we will go though some examples of how this would be useful as well as how to create new functions.

Macros similar to functions are used to create reusable pieces of code that can be changed once to effect all the instances of the Macro. In this lesson we will go though why sometimes you will want to use a macro and sometimes you will want to use a function, we will also go though creating a macro and some of its possible uses.

Structs are variables that can contains multiple different variables types inside it like for example a struct could contain a Boolean, Vector and Name variables inside one struct variable type.

Enum variables give us a user friendly way to create lists of pre defined options that can be selected in a variable.

Events are used to call nodes connected to a new chain of code. The engine includes many types of events that are run when a specific action happens like for example the Destroyed Event will run on an actor when its has been called to be destroyed, any code connected to that Destroyed event will run. In this lesson we will cover some of the common engine events as well as how to create your own.

Blueprints inheritance allows blueprints to retain the functions, variables and events from there parent blueprint but allows them to add new code without effecting the parent blueprint or event override the parents code to perform a different action without changing the parents code.

Casting is one of the ways blueprints can communicate with each other, if we know which type of actor an actor reference is we can cast to that actors type and gain access to its variables, functions and events. In this lesson we will be learning how to cast and when casting is possible.

Events dispatchers allow us to call and event on a blueprint object and have any events bound to the event call run, this can allow us to call events on many actors without having to specify to each actor to run the event.

Interfaces allow us to try and call events on actors without having to cast to the actor. If the event exist on the actor then it will be called, if it doesn't exist then the call is ignored and fails silently. In this lesson we will cover how this is a very useful system.

Components are blueprints that can be added to actors to add additional functionality, for example the ability to have a static mesh in an actor is done though using the Static Mesh component. In this lesson I will show you how to add new components as well as create your own components.

Player controllers are the representation of the player in the game, we use the controller to give instructions to the players characters.

Game modes are used to tell the engine what player controller, map or pawn blueprints we want to use. They also contain a number of built in useful events that can be helpful in managing whats happening in your game.

Utility nodes are used to control which code in your blueprints get run as well as help keep your code clean and easy to read.

Game instances are a type of blueprint that are created when your game start and exist until the game is closed.

Traces are used to get if an object is between the start and end location, using this we can get information about the object the traces hits when checking between the start and end location.

Data tables are used to store read only data that can be accessed during gameplay. They use structs to determine what information is stored in the data table.

These are nodes that can check a location and radius for actors or components.

Input events are how we run code when a player presses a key on there keyboard, moves there mouse or moves a analogue stick.

Enhanced inputs are a new UE5 feature that takes player input such as button presses, mouse movement or gamepad input and allows us to run code when this happens.

Tags give us an easy way to add additional meta data to an actor that we can use to help specify what and actor is or does without having to cast to its blueprint type.

In this lesson we will cover how to spawn new actors into a level. This is when we create a new actor in the level during game play instead of placing it in the level as the level designer.

In this lesson you will learn some helpful techniques to keep your project organized.

Blueprints have some very powerful debugging tools that can help you find and fix issues in your code. In this lesson we will cover those tools and how you can use them.

We can use timelines to output a value like a float or vector over a set amount of time to get a smooth transition between the start and end values. These are be used to move things with a smooth transition.

Sockets can be added to static or skeletal meshes and are used to attach other objects to the mesh. In this lesson will we cover how to create sockets and attach and detach objects to them.

The movement component is a component built in the engine that comes as part of the character blueprint type, we can use it to control character movement type, speed and general movement setting for out characters.

In this lesson we will learn how to spawn sounds effects. We will cover both the Audio Cue and the new UE5 MetaSounds system in the lesson.

In this lesson we will cover how to spawn Niagara particle effects using blueprints.

Widgets are used to add UI elements to your players screen, these can be used to display information and can also allow player input.

In this lesson you will learn the basics of how to control the layout (appearance) of a widget.

In this lesson we will cover how to create new widgets and add them to the screen.

Widget binding are used to attach a property of a widget to a variable or function, this allows the widget to change when the bound variable changes or when the output of the bound function changes.

Borders, Overlays and Grids are some of the most commonly used widget types and we will cover how to use them in this lesson to change the layouts of your widgets.

In this lesson we will cover how to setup widget drag and dropping, this allows your to transfer info from the widget you dragged on to the widget you drop the drag on.

In this lesson you will learn what animation blueprint are, what they are used for and how to navigate the animation blueprint UI.

Montages are used to tell the animation blueprint that we want an animation to be played. In this lesson we will cover what a montage is, how to create one and setup the code to make the montage play when you press a button.

Blend nodes are used to combine multiple animations together or switch between different animation in the animation blueprints, in this lesson we will learn about a few of these nodes and how you can control them in with blueprint code.

Animation notifys are used to spawn sounds, particle effects or run a event at a specific time in animations.

Animation States are one of the ways used to control which animation we want the animation blueprint to play.

Blend spaces allow use to input values like speed or direction and have it output a animation depending on those values and are often used for movement animations.

Aim Offsets similarly to blend spaces allow use to input values like pitch and yaw directions and have it output a animation depending on those values and are often used for controlling the direction character is looking using the aim offsets animations.

Curves and metadata allow us to add additional information to animations and montages that can be read inside the animation blueprint.

In this lesson we will create an interaction system, putting to use the things we have learnt about like interfaces, traces and input events.

In this lesson we will create a damage system using actor spawning, hit events and input events.

In this lesson we will setup a health bar widget using a progress bar and widget property binding.

In this lesson we will setup a respawn system, we will create a death screen using widget and run code using a button. We will also possess a new spawned in character.

In this lesson we will setup crouch idle and crouch movement states in our animation blueprint using blend spaces and the movement component.