# Section 1 - Project Creation Asset Pack ## 1 Project Setup We open the Startup Project and configure some settings - Downloading the project assets ## 2 Setting up Version Control We set up our project for version control using Git - Setup the git repo to gitginger:/Aura.git ## 3 The Base Character Class We create a base Character class for our game Characters to inherit from - Created the C++ project and the base character class `AuraCharacterBase` - cleaned some unused methods from it ## 4 Player and Enemy Characters We derive two subclasses from our base Character class: AuraCharacter and AuraEnemy - Derive two subclasses `AuraCharacter` & `AuraEnemy` ## 5 Character Blueprint Setup We create our Character Blueprints and set the mesh assets. We also add a Weapon to the Base Character - Create Skeletal mesh for `Weapon` in `AuraCharacterBase` - Create blueprint for Aura character with mesh and weapon models assets - Add weapon socket to the skeleton `SK_Aura` - Create blueprint for goblin spear with mesh and weapon models assets - Rename socket on skeleton `SK_Goblin` ## 6 Animation Blueprints We create an Animation Blueprint for Aura and an Animation Blueprint Template for all our Enemies - Create animation blueprint class `CharacterAnimInstance` from Howling project - Inherit Aura anim blueprint from it and setup main states machine and default slot - Create Template Animation Blueprint for enemies with main states machine and default slot - Use it for GoblinSpear with the animations - Do Goblin Slingshot as well ## 7 Enhanced Input We create our Input Action for Movement and Input Mapping Context to map input keys - Create input action for move & input action mapping on WASD - Create `AuraPlayerController` C++ class ## 8 Aura Player Controller We setup Input in the Player Controller Class - Set player controller to replicate - Add the enhanced input module - Add mapping context to the player controller and initialize it in the begin play - Setup cursor and input data in player controller ## 9 Movement Input We create a Move callback for our Move Input Action and Bind it in the Player Controller class - Create move UInputAction bind to the Move method - Implement Move method using control rotation - Create blueprint class to map assets ## 10 Game Mode We create a Game Mode and assign the Default Pawn and Player Controller Classes - Create cpp & bp for base game mode with playercontroller and pawn - Add spring arm and camera to the controlled character cpp class - Setting up spring arm, character and character movement to a top down game - Split animation blueprint main states into idle and walkrun ## 11 Enemy Interface We create an Enemy Interface function that we can use to highlight enemies when hovering over them - Create cpp class for `IEnemyInterface` - Make `AuraEnemy` implement it ## 12 Highlight Enemies We implement the highlight decision process in the Player Controller - Implement `HighlightActor` and `UnHightlightActor` for `AuraEnemy` - Check on player controller tick the hit result behind cursor - Use result for hover actor ## 13 Post Process Highlight We use a Post Process Highlight material to show a red outline of highlighted enemies - Set project `Custom Depth-Stencil Pass` to `Enabled with Stencil` for the hovering effect - Change channel visibility block for CharacterMesh preset - Create highlight property in character base class # Section 2 - Intro to the Gameplay Ability System ## 1 The Gameplay Ability System We learn what the Gameplay Ability System is and what it can do for us - Gameplay system is awesome, masterpiece of engeneering - GAS is OP ## 2 The Main Parts of GAS We learn about the main parts of GAS in this high-level overview of the Gameplay Ability System - There is 6 main parts of GAS system 1. **Ability System Component** - Actor component added to pawn or player state. Grants the set of abilities, trigger them and manage their states. 2. **Attribute Set** - Actor Component added to pawn or player state. List of attributes that have impact on abilities behaviours. 5. **Gameplay Ability** - Class that contains the full behaviour of an action. 6. **Ability Task** - Asynchronous task ran by Gameplay Abilities. 3. **Gameplay Effect** - Used to change the values of attributes directly or over time. 4. **Gameplay Cue** - Cosmetic or sound effects for states or events. 7. **Gameplay Tags** - Extended tag system with hierarchical system - We can set Ability system and Attribute set in a pawn or in a player state. It depends on the usage. ## 3 The Player State We create the Player State class for Aura - Created `AuraPlayerState` cpp & bp - Set `NetUpdateFrequency` to 100 because the ability system will be there - Set it in gamemode ## 4 Ability System Component and Attribute Set We create the Ability System Component and Attribute Set classes - Add *"GameplayAbilities"* Plugin - Created `AuraAbilitySystemComponent` & `AuraAttributeSet` cpp classes - Added *"GameplayAbilities"*, *"GameplayTags"*, *"GameplayTasks"* dependencies to private modules in build ## 5 GAS in Multiplayer We learn about how classes work in Multiplayer and what Replication is - Explaination of UE concepts. - Server, Listen, Client. - Gamemode only exists on server. - Player Controller exists on server and owning client. - Player State exists everywhere for everyone. - HUD exists only on clients. ## 6 Constructing the ASC and AS We construct the Ability System Component and Attribute Set for the Enemy and for the Player Controlled Character - Add the AbilitySystemComponent and AttributeSet pointers in the base character class - Create instance in enemy character class and player state - Move module *"GameplayAbilities"* from private to public build - Make base character class and player state class inherit `IAbilitySystemInterface` - Implement the `GetAbilitySystemComponent` method in both classes - Implement similar method to get attribute set ## 7 Replication Mode We learn about the Replication Mode for Ability System Components - Set replication mode for ability system component to Mixed for player and Minimal for AI controller character ## 8 Init Ability Actor Info We learn how to set the Owner Actor and the Avatar Actor for our Ability System Component - AbilitySystemComponent has two owners - OwnerActor: The one spawning and owning it (Character or PlayerState) - AvatarActor: The representing pawn in the world - When using Mixed, the OwnerActor's Owner must be the controller - Initialize ability system with method `AbilitySystemComponent->InitAbilityActorInfo(OwnerActor, AvatarActor)` after pawn has been possessed - AuraEnemy: During BeginPlay as it's only part of the actor - AuraPlayerState: After possessing a pawn. OnPossessed on server and OnRep_PlayerState on client - Player Controlled Pawn: After PossessedBy for server and AcknowledgePossession for client - At this point, playing with 2 players listen/client crashes # Section 3 - Attributes ## 1 Attributes We learn what Attributes are, how they are stored, and how the preferred way to change them is through Gameplay Effects - Attributes are stats a player can have - We prefer to modify attributes with effects to help with prediction - We can have multiple attributes sets ## 2 Health and Mana We add our first Attributes to our Attribute set: Health and Mana - We create attributes in the attribute set class - `FGameplayAttributeData` type and replicated variable - Attributes for Health, MaxHealth, Mana, MaxMana - To create a replicated variable 1. Implement the lifetime - `virtual void GetLifetimeReplicatedProps(TArray& OutLifetimeProps) const override;` - implementation with super call 2. Create the variable - `UPROPERTY(ReplicatedUsing = OnRep_MyValue) MyType MyValue;` - `UFUNCTION() void OnRep_MyValue(const MyType& OldMyValue) const;` 3. Define replication condition in `GetLifetimeReplicatedProps` - `DOREPLIFETIME_CONDITION_NOTIFY(UMyClass, MyValue, COND_None, REPNOTIFY_Always)` - add the header `#include "Net/UnrealNetwork.h"` 4. For gameplay attributes, add the gameplay attribute notifier in `OnRep_MyValue` - `GAMEPLAYATTRIBUTE_REPNOTIFY(UMyClass, MyValue, OldMyValue)` - add the header `#include "AbilitySystemComponent.h"` ## 3 Attribute Accessors We learn about the Attribute Accessor macros provided by the Ability System - We can create accessors (getter & setters) for attributes - The macro will generate them all ```cpp #define ATTRIBUTE_ACCESSORS(ClassName, PropertyName) \ GAMEPLAYATTRIBUTE_PROPERTY_GETTER(ClassName, PropertyName) \ GAMEPLAYATTRIBUTE_VALUE_GETTER(PropertyName) \ GAMEPLAYATTRIBUTE_VALUE_SETTER(PropertyName) \ GAMEPLAYATTRIBUTE_VALUE_INITTER(PropertyName) ``` > \> ShowDebug AbilitySystem - Added the Init functions to the attribute set constructor ## 4 Effect Actor We create an effect actor designed to change attributes - Created `AuraEffectActor` cpp with an overlapping sphere and a root mesh - Add the OnOverlap and EndOverlap methods triggered by the sphere collision - On overlap, extract the ability system using cast to IAbilitySystemInterface and modify attributes - Created derived BP_HealthPotion that add to health and get destroyed when an actor overlapps with it. # Section 4 - RPG Game UI ## 1 Game UI Architecture We lay out the plan for our game's UI architecture - We're gonna use a MVC model - View is widgets - Model are attribute sets and ability system component - Controller will be a new `UObject` subclass. ## 2 Aura User Widget and Widget Controller We create our base Widget and Widget Controller classes - Create Root Widget cpp class and UObject Controller cpp class - The root widget has a reference to a controller object - The controller has a reference to PlayerController, PlayerState, AbilitySystemComponent and AttributeSet ## 3 Globe Progress Bar We create the Globe progress bar, making use of widget inheritance - Globe Progress bar with modifiable variables ## 4 Health Globe We derive a Health Globe and Mana Globe widget based on our Globe Progress Bar - Create the overlay widget with a health and mana globe ## 5 Aura HUD We create the HUD class for our project - Create AuraHUD cpp & bp class with a widget class to add to viewport on begin play - Set the BP_AuraHUD as hud class in gamemode ## 6 Overlay Widget Controller We make an Overlay Widget Controller for the Overlay widget in our Viewport - BIG FIX: We should not use TObjectPtr with type that are not subclasses of UObject (like IInterface) - Create struct `FWidgetControllerParams` in AuraWidgetController.h to group parameters from the controller - Create `UOverlayWidgetController` subclass of AuraWidgetController and singleton access from `AAuraHUD` with `GetOverlayWidgetController(...)` - Add `OverlayWidgetController` reference and `OverlayWidgetControllerClass` in AuraHUD - Add InitOverlay in AuraHUD to create the overlay widget which is no longer created in its begin play - Call InitOverlay in character InitAbilityActorInfo - Fix to not assert for input subsystem in player controller begin play which causes crash in multiplayer ## 7 Broadcasting Initial Values We learn how to broadcast initial values from the Widget Controller to the Widgets - Add method `BroadcastInitialValues` to AuraWidgetController class - Created broadcast delegates in `UOverlayWidgetController` - Created the blueprints `BP_OverlayWidgetController` - Make `WBP_HealthBar` and `WBP_ManaBar` subscribe to broadcast to update widgets - To make an event dispatcher 1. Declare its signature with `DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnSomethingSignature, MyType, MyValue)` 2. Add the property to the class `FOnSomethingSignature OnSomething` 3. Call it using `OnSomething.Broadcast(MyValue)` ## 8 Listening for Attribute Changes We learn how to listen for attribute changes in the Ability System - Create methods in `UOverlayWidgetController` for `HealthChanged` and `MaxHealthChanged` - Add `BindCallbacksToDependencies` to widget controller to subscribe for callbacks. Called at the end of `SetWidgetControllerParams` - `UOverlayWidgetController` subscribes for changed from attribute set health, maxhealth, mana, maxmana and uses implemented functions for it ## 9 Callbacks for Mana Changes We create callbacks for mana attribute changes - Nothing # Section 5 - Gameplay Effects ## 1 Gameplay Effects We learn what Gameplay Effects are and how they can be used to modify Attributes - `UGameplayEffect` - Used to change attributes and gameplay tags - Should not be subclassed - contains modifiers and executions. modifiers define what to do with a value (add, multiply, replace, ...) and have a magnitudes influenced by things (attributes, scalar values, set by caller, ...) - has duration policy (instant, duration, infinite (until manually removed)) - can stack in customized way - can add gameplay tags or abilities or other things - "gameplay effect spec" is a lightweight version ## 2 Effect Actor Improved We improve our Effect Actor so it is more versatile and can apply gameplay effects - Remove mesh, sphere and overlap methods (kind of everythings) - Added method `ApplyEffectToActor` usable from the blueprint - Add gameplay effect class and effect level properties to set on blueprint side - Use actor's gameplay ability component to apply the effect to himself ## 3 Instant Gameplay Effects We create an Instant Gameplay Effect and apply it on overlap with our Potions - Create abstract blueprint BP_Potion to create health and mana - a potion has a sphere collision and a mesh - colliding actor will get effect applied - if effect successfully applied, destroy the actor - Create Gameplay effect for heal potion and mana potion and assigned them to the blueprints - modifier -> Op Add -> Magnitude Scalable float of some value ## 4 Duration Gameplay Effects We learn about Duration Gameplay Effects - Created new potions and effects to hurt ourself - Create new materials for the new potions - When defining a duration for an effect, it will apply then reverse at the end of the time ## 5 Periodic Gameplay Effects We learn the difference between Duration and Infinite Gameplay Effects and those with Periodic behavior - Effects have a period parameter to apply over time - period time will tick and trigger the full effect each times - make hurt effect occur over time ## 6 Effect Stacking We learn how effects can stack and cover the parameters for stacking - Can stack by target or by source - in wow, heals should be by target and dot by source - stack can be limited and have rules for stack expirations ## 7 Infinite Gameplay Effects We add an Infinite Gameplay Effect to our Effect Actor - Effect can be infinite. Applied and removed mannualy ## 8 Instant and Duration Application Policy We add an application and removal policy for the effects in our Effect Actor - Stupid overengeneering thing chapter ## 9 Infinite Effect Application and Removal We learn how we can remove infinite gameplay effects and create a Fire Area. - `AAuraEffectActor` now has a map of [ASC: ActiveEffectList] to register applied effects that are not instants - As map cannot have TArray as value type, we have to define an intermediate struct containing the array - Added the functionnality to remove effects using the map - We only remove one stack of the effect ## 10 PreAttributeChange We learn about PreAttributeChange and how we can use it to clamp Attribute changes - implement the function `PreAttributeChange` in the attribute system - it is triggered before changing an attribute to modify the future value - used to clamp health and mana modifications to stay in bounds ## 11 PostGameplayEffectExecute We learn about PostGameplayEffectExecute and the plethora of values we can harvest in it about a Gameplay Effect - implement the method `PostGameplayEffectExecute` to recieve informations about executed effects - Create `ExtractEffectModProperties` that extract many informations from the effect into a struct `FEffectProperties` ## 12 Curve Tables for Scalable Floats We learn how to create Curve Tables so we can scale the value in our Gameplay Effect using a Scalable Float Magnitude Calculation - Effects magnitudes can be scaled with level using curve from curve tables - Created a curve table for heal and mana potion effects # Section 6 - Gameplay Tags ## 1 Gameplay Tags We learn what Gameplay Tags are and why they are so useful - Tags are used to define states of things in an universal way unlike using enums ## 2 Creating Gameplay Tags in the Editor We learn how to create Gameplay Tags from within the editor - Created tags in the project settings gameplay tags for all four attributes ## 3 Creating Gameplay Tags from Data Tables We learn how to create Data Tables that are converted into Gameplay Tags - Created tags in a data table and added it to the tag data tables ## 4 Apply Gameplay Tags with Effects We learn how to add Gameplay Tags for Gameplay Effects - Tags can be granted with effect - Tags stacks - We should read the `AbilitySystemComponent.h` file ## 5 Gameplay Effect Delegates We learn how to respond to Gameplay Effect application via the Ability System Component's built-in delegates - Create method `OnEffectApplied` in `UAuraAbilitySystemComponent` - Subscribe to delegate when effect is applied to trigger effect applied in a new method `AbilitySystemInitDone` - Renamed `InitAbilityActorInfo` to `InitAbilitySystem` and move it to root character class as virtual - Make it call `AbilitySystemInitDone` - Bind delegate to ability system component and character when effect applied - `ASC->OnGameplayEffectAppliedDelegateToSelf.AddUObject(this, &UThis::Method)` ## 6 Get All Asset Tags We learn how to get all Asset Tags on a Gameplay Effect in C++ - Inspect Tag with `EffectSpec.GetAllAssetTags` to list effect tags ## 7 Broadcasting Effect Asset Tags We learn how to broadcast a Gameplay Tag Container filled with Asset Tags to the Widget Controller - Add multicast delegate `OnEffectAssetTags` to ability system component - Trigger multicast when effect is applied - Add a lambda function to overlay widget controller and subscription to it - Troubleshooting time. Sometimes, we should refresh blueprint nodes ```cpp OnThingDelegate.AddLambda([this](MyType MyValue) { // Lambda code here }); ``` ## 8 UI Widget Data Table We learn how to create a Data Table to hold widget information for messages - Created struct matching gameplay tags to widgets - Add the DataTable property to widget controller - Created a table and set it in the blueprint properties ## 9 Retrieving Rows from Data Tables We create a function for finding Data Table rows corresponding to message Gameplay Tags - We can read from data table in C++ ```cpp FMyType* Row = MyDataTable->FindRow(FName("MyKey"), TEXT("")); ``` ## 10 Broadcasting Data Table Rows We learn how to broadcast data from Data Table rows to Widget Blueprints - Tag matching - "Attribute.Agility" matches "Attribute" - "Attribute" does not match "Attribute.Agility" ## 11 Message Widget We create the message widget for when we add a message tag to a gameplay effect - Created message widgets and push them when an effect tags triggers ## 12 Animating the Message Widget We animate the message widget - Created an animation to play when spawning message widget - Destroy the widget after the animation ## 13 Replacing Callbacks with Lambdas We learn how to replace callback functions to lambdas which we bind to delegates instead - Replaced method callbacks with lambdas in overlay widget controller - Combined signatures of attribute changes into one ## 14 Ghost Globe We are challenged to create a Ghost Globe that trails behind the Health and Mana Globes - Ghost trail globe interpolating to correct value in tick ## 15 Properly Clamping Attributes We learn how to properly clamp attribute changes via PostGameplayEffectExecute - Clamp attributes in PostGameplayEffectExecute instead of PreAttributeChange # Section 7 - RPG Attributes ## 1 Initialize Attributes from a Data Table We learn how to initialize Attributes by setting values in a Data Table - Added other attributes for Strength, Intelligence, Resilience and Vigor - We can create a data table for attributes using AttributeMetaData - Set it in the default ability component system DefaultStartingData - This method is not the best one ## 2 Initialize Attributes with Gameplay Effects We learn how to initialize Attributes with the use of a Gameplay Effect - Move common types in file `AbilitySystemTypes.h` - Ability system component has list of starting effects to apply - The course set it in the character but executes it at the same place - Check some possible invalid cases - Created the starting effect for all attributes - Remove usage of data table - Starting attributes effect is of type instant and use override on primary attributes ## 3 Attribute Based Modifiers We learn how to modify an Attribute in a Gameplay Effect with a modifier based on other Attribute values - We can apply modifier on effect using attribute of ether source or target ## 4 Modifier Order of Operations We learn how the math works behind modifiers and go over several examples - Modifier occurs in order. That's why it's better to modify max health before health ## 5 Modifier Coefficients We learn how modifiers can have coefficients to create more complex modifier math - Three parameters Coeficients, PreMultiplyAdditiveValue, PostMultiplyAdditiveValue - NewResult = (Value + PreMultiplyAdditiveValue) * Coeficients + PostMultiplyAdditiveValue ## 6 Secondary Attributes We create the Secondary Attributes for our RPG project - Secondary attributes are depending on primary attributes - Created secondary attributes for Armor, ArmorPenetration, BlockChance, CriticalHitChance, CriticalHitDamage, CriticalHitResistance, HealthRegeneration, ManaRegeneration - Set MaxHealth and MaxMana as secondary attributes ## 7 Derived Attributes We learn how to derive Attributes from other Attributes, so when the backing Attribute changes, so does the derived Attribute - To make a derived attribute, we can use an infinite gameplay effect that override attributes using backing primary attributes - Created GE_SecondaryAttribute with infinite duration - Armor = 0.5 * Resilience + 10 - Armor Penetration = 0.25 * Resilience + 0.5 * Strength - Block Chance = 0.25 * Armor - Crit Chance = 1.0 * Armor Pene + 0.5 * Intelligence - Crit Damage = 4.0 * Armor Pene + 2.0 * Intelligence - Crit Resistance = 0.1 * (Armor - 10.0) - Health Regen = 0.5 * Vigor - Mana Regeneration = 0.5 * Intelligence - Max Health = 5.0 * Vigor + 10.0 + Level - Max Mana = 5.0 * Intelligence + 10.0 + 10.0 * Level - When setting override and add, the override overrides. Order doesn't matter ## 8 Custom Calculations We learn how Modifier Magnitude Calculations (MMC) can have arbitrarily complex modifiers. - To modifiers depending on multiple attributes or complex method, we use MMC ## 9 Player Level and Combat Interface We add Level to our Player State and create the Combat Interface so we can get the Level of an entity in the game - Created Replicated value `Level` in `AAuraPlayerState` - Same but not replicated in AuraEnemy - Create CombatInterface cpp with GetPlayerLevel method - CharacterBase implement Combat interface - AuraEnemy return his level - AuraCharacter return player state level ## 10 Modifier Magnitude Calculations We learn how to create Modifier Magnitude Calculations (MMC) to have arbitrarily complex modifiers. - We create a MMC, cpp class used to make custom attribute modifier calculation ```cpp // Header UCLASS() class MY_API UMMC_MyCalcul : public UGameplayModMagnitudeCalculation { GENERATED_BODY() public: UMMC_MyCalcul(); virtual float CalculateBaseMagnitude_Implementation(const FGameplayEffectSpec& EffectSpec) const override; private: // Create as many to capture all attributes we need FGameplayEffectAttributeCaptureDefinition AttributeDef; }; // Cpp UMMC_MyCalcul::UMMC_MyCalcul() { AttributeDef.AttributeToCapture = UMYAttributeSet::GetMyAttributeAttribute(); AttributeDef.AttributeSource = EGameplayEffectAttributeCaptureSource::Target; AttributeDef.bSnapshot = false; RelevantAttributesToCapture.Add(AttributeDef); } float UMMC_MyCalcul::CalculateBaseMagnitude_Implementation(const FGameplayEffectSpec& EffectSpec) const { // Gather tag from source and target const FGameplayTagContainer* SourceTag = EffectSpec.CapturedSourceTags.GetAggregatedTags(); const FGameplayTagContainer* TargetTag = EffectSpec.CapturedTargetTags.GetAggregatedTags(); FAggregatorEvaluateParameters EvaluationParameters; EvaluationParameters.SourceTags = SourceTag; EvaluationParameters.TargetTags = TargetTag; float MyAttribute = 0.0f; GetCapturedAttributeMagnitude(AttributeDef, EffectSpec, EvaluationParameters, MyAttribute); // Can fetch many other values from context // EffectSpec.GetContext().GetSourceObject() return MyAttribute * MyAttribute; } ``` ## 11 Initializing Vital Attributes We initialize the Vital Attributes with a Gameplay Effect - Fix anomaly in blueprint - Create MMC for derived attributes - To heal full life, make effect that give health equal to maxhealth Small modifications - Removed cpp MMC for derived attributes and used a base class for all derived attributes - Made multiple blueprints class for all derived attributes - TODO: Fix player level interface in c++ to use in bp # Section 8 - Attribute Menu ## 1 Attribute Menu - Game Plan We lay out the Game Plan for our Attribute Menu - Menu widget preparation ## 2 Attribute Menu - Framed Value We create the Framed Value widget that we can reuse in other widgets - FramedValue widget ## 3 Attribute Menu - Text Value Row We create a Text Value Row widget that has text as well as a Framed Value - Made text value row with a named slot ## 4 Attribute Menu - Text Value Button Row We create the Text Value Button Row widget that makes use of the Named Slot so we can take advantage of widget inheritance - Made inheriting text value row with button ## 5 Attribute Menu - Construction We begin construction of the Attribute Menu widget itself - Made Attribute Panel Menu with list of previously made widgets ## 6 Button Widget We make a Button widget that we can reuse in any number of situations - Make a reusable button widget ## 7 Wide Button Widget We subclass the Button widget into a Wide Button that looks pretty darn spiffy - Same button but wider ## 8 Opening the Attribute Menu We implement functionality for opening the Attribute Menu - Use a button to show or hide attribute menu ## 9 Closing the Attribute Menu We implement functionality for closing the Attribute Menu - Already done lol - Using destruct to call OnClosed ## 10 Plan for Displaying Attribute Data We create a plan for displaying the Attribute Data in a well-coded manner - Need a way to update data to attribute menu - Can have widget controller observing each attributes but that's not scallable - Have instead a controller that broadcast when a value change with a tag - Each widget will have his own tag and only react if it matches - Assiociation of tag and secondary attributes on cpp side ## 11 Gameplay Tags Singleton We create a singleton for storing native Gameplay Tags that we wish to access from C++ - Make singleton `AuraGameplayTags` `to generate gameplay tags in cpp - add an initialization method to generate tags ## 12 Aura Asset Manager We create our own custom Asset Manager for the project and configure the project to use it, initializing the Gameplay Tags singleton - Create a singleton from type `UAssetManager` - Get method to retrieve the singleton - get the `GEngine->AssetManager` - cast it to our type and return it - override `StartInitialLoading` - get `AuraGameplayTags` singleton and use the initializer - Set the new asset manager type to be the project Asset Manager class - Add one gameplay tag example in the AuraGameplayTag ## 13 Native Gameplay Tags We add native Gameplay Tags, creating them an accessing them from C++ and Blueprint - Add cpp gameplay tag for all primary and secondary attributes ## 14 Attribute Info Data Asset We create a Data Asset to store Attribute Info so we can broadcast it from the Widget Controller - Create data asset for attribute infos containing tag, name, description and value - Create the blueprint value and initialize it with all attributes ## 15 Attribute Menu Widget Controller We create the Attribute Menu Widget Controller - Create new widget controller for attribute menu ## 16 Aura Ability System Blueprint Library We make our very own Blueprint Function Library so we can expose hidden gems in C++ to the Blueprint side - Created a blueprint library function to get overlay widget controller from anywhere ## 17 Constructing the Attribute Menu Widget Controller We construct the Attribute Menu Widget Controller - Copy the method to get overlay widget controller with attribute menu controller ## 18 Attribute Info Delegate We make the Attribute Info Delegate, capable of broadcasting Attribute Info up to Widget Blueprints - attribute widget delete subscribes to some infos - create methods in widgets to display received data ## 19 Widget Attribute Tags We give each row in the Attribute Menu its own Gameplay Tag associated with an Attribute - Add gameplay tag value to each widgets to define the observed value - Use macro to broadcast all attributes in the attribute menu controller ## 20 Mapping Tags to Attributes We map Gameplay Tags to Attributes in the Attribute Set so we can easily figure out which Attribute is associated with which Attribute Tag - In the course, creating a map marching gameplay tags with attributes - attributes are set a typedef of function calling - did not understand everything here, big things about templating types ## 21 Responding to Attribute Changes We implement a callback for responding to changes in the values of our Attributes - The course uses the tag map to write a more elegant solution with less boilerplate. - But it goes throught the O(n) for loop each time it's requesting an attribute info in the dataasset # Section 9 - Gameplay Abilities ## 1 Gameplay Abilities We briefly go over what Gameplay Abilities are, what they can do, and how they work - Gameplay Ablity - Class that define a skill or ability - Must be granted - Granted on server - Spec replicated to client - Used on activation - Can have resource cost and cooldown - Run asynchronously - can have multiple executions at the same time - Ability task is asynchronous operation - send delegate informations ## 2 Granting Abilities We learn how to grant Gameplay Abilities to an Ability System Component - Made root ability class - Add list of ability in characters - Method to add all abilities from a character - We grant ability with the ability component system - we can grant and instantly use ## 3 Settings on Gameplay Abilities We go over the numerous settings on the Gameplay Ability Blueprint - Abiliy can be instanced in three way - Never instanced and used as singleton ability in the game - Instanced once per actor and reused each uses - Instanced each executions - `NetExecutionPolicy` Can choose a replication policy to predict or not - Cost and cooldown are setup with gameplay effects - Things not to do - "Replication Policy" is useless says Epic - "Server Respect Remote Ability Cancellation" should not be - "Replicate Input Directly" is discouraged ## 4 Input Config Data Asset We create a Data Asset to map Input Tags to Input Actions - Input actions bounds to input with input mapping context - We're going to make changing ability buttons possible - Created a data asset for input config - A struct that link an input action to a gameplay tag - The data asset contains a array of this struct - Added tags in cpp for inputs abilities and matching Input Action assets (as bool) - Link them all in the input mapping context ## 5 Aura Input Component We create our own Enhanced Inpuit Component capable of mapping callback functions to Input Actions by Gameplay Tag - Created our own input component type from type `UEnhancedInputComponent` - Add template method that bind an ability action from our previous data set and send action tag - `template void BindAbilityActions(const UAuraInputConfig* InputConfig, UserClass* BindObject, PressedFuncType PressedFunc, ReleaseFuncType ReleaseFunc, HeldFuncType HelfFunc)` ## 6 Callbacks for Ability Input We create callbacks on the Aura Player Controller class that will be bound to the Input Actions and receive their Input Tags - Add the data asset ability input config to our player controller and set it in the bp - Create callback function for ability pressed, released and held in player controller - use the previous template method from the input component to bind ability actions to callback ## 7 Activating Abilities We learn how to Activate Abilities in the Ability System Component based on the Input Tags associated with them - In gameplay ability class - Add a tag for the trigger input - can be changed at runtime for the player - In the ability system component - Modify the spec to add the input tag from the aura ability class - Add functions for input tag held and released - Check with a O(n) for loop if we have an ability spec with matching input tag - Activate or release it if we do - In player controller - Add reference to the ability system component - Use ability input callback functions to call ability system component matching functions ## 8 Click To Move We lay out a ground plan for Click-To-Move behavior - The standard template top down game does not manage click to move for clients - We will implement our own way using the pathfinder and a spline to smooth the result ## 9 Setting Up Click to Move We set up the Click-To-Move system - When player click, we save if there was an hovered enemy - When the click is hold - In case of a targeted enemy, we proceed with ability trigger - In case of no enemy - we add the delta time to follow time - Line trace under cursor to cached destination - Add movement input to the controlled pawn toward the cached destination ## 10 Setting Up Auto Running We add the Auto-Running mechanic to our Click-To-Move system - When player release click - In case of no targeted enemy and the follow time is quick enough - Pathfind from pawn location to cached destination - Add the points to the spline - set the cached destination to the last point of the spline - Also added a nav mesh volume and obstacles in the world and "NavigationSystem" to modules ## 11 Implementing Auto Running We finish Click-To-Move's Auto Running mechanic - new function `AutoRunTick` used from player controller tick function - get the closest spline point and direction from the pawn - add the direction to the pawn movement input - Allow client side navigation in project settings ## 12 Code Clean Up We clean up the code in the Aura Player Controller class and make sure things work in multiplayer - player controller cache cursor hit on tick - OnEffectApplied is now triggered on client ```cpp // To write Remote Function Call (RFC) /* MyClass.h */ UFUNCTION(Client, Reliable) void ClientMyFunction(); UFUNCTION(Server, Reliable) void ServerMyFunction(); UFUNCTION(NetMulticast, Reliable) void MulticastMyFunction(); /* MyClass.cpp */ void ClientMyFunction_Implementation() { /* */ } void ServerMyFunction_Implementation() { /* */ } void MulticastMyFunction_Implementation() { /* */ } ``` ## 13 Aura Projectile We create a Projectile class that we can spawn with a Gameplay Ability - Create a basic projectile actor - sphere collider component - projectile movement component - speed 550 - no gravity - editor arrow - Overlap with channels WorldDynamic, WorldStatic, Pawn - Made a firebolt from projectile ## 14 Aura Projectile Spell We create the Gameplay Ability that we will use to spawn projectiles - Create subclass of base gameplay ability for projectile ability - Lot of informations about what an ability can do by reading `GameplayAbility.h` in the engine - K2 prefix is a legacy feature means Kismet2 which has been replaced by Blueprint. It is now used to prefix a function that should be implemented in blueprint - ActivateAbility is not directly use. We should use TryActivateAbility to check for prerequisistes - The important functions - CanActivateAbility() - const function to see if ability is activatable. Callable by UI etc - TryActivateAbility() - Attempts to activate the ability. Calls CanActivateAbility(). Input events can call this directly. - Also handles instancing-per-execution logic and replication/prediction calls. - CallActivateAbility() - Protected, non virtual function. Does some boilerplate 'pre activate' stuff, then calls ActivateAbility() - ActivateAbility() - What the abilities *does*. This is what child classes want to override. - Should call CommitAbility and EndAbility - CommitAbility() - Commits reources/cooldowns etc. ActivateAbility() must call this! - CancelAbility() - Interrupts the ability (from an outside source). - EndAbility() - The ability has ended. This is intended to be called by the ability to end itself. - Can get owning actor, actor skeletal mesh component - Many shortcut to activate effects - The blueprint ActivateAbility is called before the cpp ## 15 Spawning Projectiles We actually spawn fireballs with our new Gameplay Ability, but learn that there are a few more things we must implement when we learn about Ability Tasks - Replicate projectiles - Add method to get combat socket in CombatInterface - Character Base will return a socket location in the weapon - Projectile Ability has class parameter - Aura projectile ability - has effect on server - Spawn actor at location of combat interface socket - Added sockets to the weapon skeleton ```cpp // To spawn an actor AActor* MyActor = GetWorld()->SpawnActorDeferred(MyClass, SpawnTransform, OwnerActor, Cast(CasterActor), ESpawnActorCollisionHandlingMethod::AlwaysSpawn); /* Can do things before the construction script here */ MyActor->FinishSpawning(SpawnTransform); // SpawnActor also exist and has no need to call finish spawning afterward ``` # Section 10 - Ability Tasks ## 1 Ability Tasks We learn about Ability Tasks, what they are, and how we can use them in Abilities - `UAbilityTask` can be inherited to create our own tasks - `DECLARE_DYNAMIC_MULTICAST_DELEGATE(FMyDelegate)` to declare delegate type - can have multiple delegates that will appear in the node - We should use ability task for everything that wait for something like montage waiting for notify ## 2 Sending Gameplay Events We learn how to send a Gameplay Event to an Actor and listen for that Event in an Ability with an Ability Task - Created a anim notify that send a gameplay tag to the actor when triggered ## 3 Spawn FireBolt from Event We spawn a Fire Bolt in response to receiving a Gameplay Event - Projectile ability has a function to spawn ability - The blueprint will call the spawn after an awaited event ## 4 Custom Ability Tasks We learn how to create a custom Ability Task class - tasks have a method `Activate` that triggers to execute the job - can write a creation method and delegates so it will all appear in a blueprint create node - Created an ability task to get data under cursor ```cpp // Method to have a create task blueprint node UFUNCTION(BlueprintCallable, meta = (DisplayName = "MyTask", HidePin = "OwningAbility", DefaultToSelf = "OwningAbility", BlueprintInternalUseOnly = true)) static UMyStask* CreateMyTask(UGameplayAbility* OwningAbility); // BlueprintAssignable delegate values will have an execution pin from the creation blueprint node // Add at top of the file DECLARE_DYNAMIC_MULTICAST_DELEGATE_xxxParams(FMyTaskEventSignature, /* [...] */) // Add delegate for each trigger pin UPROPERTY(BlueprintAssignable) FMyTaskEventSignature MyTriggerableEvent; ``` ## 5 Target Data We learn about Target Data and how we can use it to send data from Client to Server - Target Data is a structured way of managing target informations for abilities - Actor Array - source location - list of actor - Location Info - source location - target location - Single Hit Result - hit result - Abilities have a delegate ready for target data updates - Ability task should use `ShouldBroadcastAbilityTaskDelegates()` to check if they can broadcast informations ## 6 Send Mouse Cursor Data We set up our Ability Task to send Target Data to the server - Create method to send cursor hit result informations - Switched delegate parameter type from vector to targetdata hitresult ## 7 Receiving Target Data We implement receiving Target Data by the server in our Ability Task - Subscribe on server for target data delegate to broadcast the data - check if the target data delegate already occured and turn in waiting state if not - Add the line `UAbilitySystemGlobals::Get().InitGlobalData();` to the initial loading of the asset manager ## 8 Prediction in GAS We learn how GAS implements its Prediction with the use of Prediction Keys - The prediction key is the hash identifier created when the ability activates - It is used to identify predicted events from a client to match with future server behavior - Every side effects of the ability have another prediction key - More infos in file `GameplayPrediction.h` ## 9 Orienting the Projectile We use our Target Data and orient the Projectile correctly on clients and server - Add the target location parameter to spawn projectile - Add the hold position action ## 10 Motion Warping We use Motion Warping to orient Aura toward the Projectile's direction - Add the motion warping plugin - Add motion warping state notify during the ability montage - WarpTargetName = "FacingTarget" - Warp rotation only. Facing - Add motion warping component to aura character - Get warping component from ability start to set the target ## 11 Projectile Impact We implement Impact sound effects and visuals - Add on impact broadcast in aura projectile to manage impact behavior on blueprint side ## 12 Projectile Collision Channel We create a custom Collision Channel for the Projectile - Create a projectile collision channel default to ignore - pawn, character mesh, destructible will overlap ## 13 Projectile Gameplay Effect We create a Gameplay Effect for our Projectile to apply when it hits something in the Level - add projectile spawns with a `FGameplayEffectSpecHandle` created from the spawner asc and has a method to apply effect to a target asc - projectile ability has an effect class - To expose a variable as pin from spawn `UPROPERTY(meta = (ExposeOnSpawn = true))` ## 14 Enemy Health Bar We create an Enemy Health Bar and get it working - Add delegate in character base for percent health change - Create health progress bar widget - Add the health bar to enemy character - Use character as widget controller and subscribe to the on percent health change to update the widget ## 15 Ghost Bar We add a Ghost bar to our Progress Bar widget - Ghost bar for enemy health widget # Section 11 - RPG Character Classes ## 1 RPG Character Classes We discuss how we will be handling RPG Character Classes and their default Attributes - Should change starting effect to data assets to make easy prefab of effect lists ## 2 Character Class Info We create a Data Asset to hold the default Gameplay Effects and Abilities for each Character Class - Made data asset for character class infos - name - class gameplay tag - base effects (scaling with levels) - on begin effects (applied on begin) - Move StartingEffects from ability system component to class info - Apply base effects after character base ability system initialization - Add list of base effects handles in character base class ## 3 Default Attribute Effects We create the Gameplay Effects to initialize the default Attributes for Enemies - Enemies have differente base attributes but similar secondary attribute scaling ## 4 Curve Tables - CSV and JSON We learn how to create CSV and JSON files from our Curve Tables, and how to make Curve Tables from these file formats - Curve tables can be exported in csv - JSON can be imported as Data table, Curve table, Float curve, Vector curve, Linear color curve ## 5 Initializing Enemy Attributes We initialize our Enemy Attributes based on their Character Class and Level - The course is using one date asset in the game mode to define the attributes of an enumeration class carried by all characters # Section 12 - Damage 128 vids so far ## 1 Meta Attributes We learn how Meta Attributes can act as intermediary Attributes, allowing for calculations before the actual Attributes are affected - Meta attribute can perform calcul before applying attribute changes ## 2 Damage Meta Attribute We create our Damage meta attribute - A meta attribute is set in the attribute set but not replicated as it is only used by the server - Added a meta attribute `IncomingDamage` in the aura ability set - Add post gameplay effect execute for incoming damage - save new incoming damage and set it to zero - modify health using incoming damage and clamp - we have here the possibility of customizing the damage taking ## 3 Set By Caller Magnitude We learn about the Set by Caller Magnitude and how to use it - Create gameplay tag for damages - Use `AssignTagSetByCallerMagnitude` to modify an effect spec handle value giving the tag and value - Set the firebolt damage to a defined value ## 4 Ability Damage We give our Gameplay Ability class a Scalable Float that we can use a Curve Table for to scale Damage based on Level - `FScalableFloat` is a struct that can be used a property. It can be a constant float or a curve table scaling value - Add the scalable float damage in base gameplay ability with a getter scaling from the ability level ## 5 Enemy Hit React We create an Enemy Hit React Ability - Reacting is an ability - Being in a hit reaction is a gameplay tag - HitReact effect - infinite - grant tag Effects.HitReact - Register to a change of gameplay tag with `AbilitySystemComponent->RegisterGameplayTagEvent(MyGameplayTag, EGameplayTagEventType).AddLambda([](const FGameplayTag& CallbackTag, int32 NewCount) {});` - GameplayTagEventType can be `NewOrRemoved` or `AnyCountChange` - Character base has a bool value to check if is hitreacting updated by the callback - Hit react ability - Grant hit react effect - Play hit react montage - Remove hit react effect when montage ends - combat interface has a montage for hit react - add the hit react montage in character base, set for all classes ## 6 Activating the Enemy Hit React Ability We activate the Enemy's Hit React Ability - When attribute set receive incoming damage, check if is fatal - If not, activate ability with tag Events.HitReact - Added the hit react ability to each class data assets - Hit react set "Retrigger instanced abilities" to chain hit react ## 7 Enemy Death We create a Death Ability - Add the blueprint implementable Die method to combat interface - implemented by blueprint to multicast a drop weapon and enable ragdoll - triggered by fatal damages ## 8 Dissolve Effect We implement a Dissolve Material Effect for when the Enemy dies - Handle death in multicast cosmetic to change material to dynamic instanced dissolvable material and trigger a timeline that changes its parameters ## 9 Floating Text Widget We create a Widget for showing the Damage caused with floating text - Creating floating text widget with animation ## 10 Showing Damage Text We actually show the floating text when a Character is damaged - In player controller, add client rfc method to show a damage dealt event implemented in blueprint - Trigger the method when an attribute set is receiving incoming damages ## 11 Execution Calculations We learn about Execution Calculations, their strengths and caveats, and what they're capable of - Customizable way to modify attribute in effects - Can use programming logic - No prediction - Only instant or periodic - Does not run PreAttributeChange - Only executed on server (Not working with LocalOnly abilities) ## 12 Damage Execution Calculation We create our own Damage Execution Calculation and learn what values can be accessed in it - created exec calc for damages - capture usefull informations in execute ## 13 ExecCalcs - Capturing Attributes We learn how to capture Attribute values in the Damage Execution Calculation - Create custom attribute based exec calc that can capture source datas ## 14 Implementing Block Chance We capture the Block Chance Attribute and take it into account when determining if there was a successful Block - Add the block chance to the relevant attributes to capture in the damage calculator - When a block occurs, divide damages by 2 ## 15 Implementing Armor and Armor Penetration We implement Armor and Armor Penetration in our Damage ExecCalc - Add the armor of the target and armor penetration of the source in the relevant attributes to capture - Armor penetration will decrease armor and armor left will decrease damage taken ## 16 Damage Calculation Coefficients We create Curve Tables for the coefficients in our Damage calculations and replace hardcoded "magic numbers" - In the course, the ExecCalc for damages will use a curve table to decrease block chances per level ## 17 Implementing Critical Hits We implement Critical Hits, taking into account the Critical Hit Chance, Resistance, and Damage Attributes - Critial hit can occurs and will multiply damages by 2 plus a bonus using critial damages decreased by critical resistance. Resistance cannot decrease damages less than initial damages - there are 3 types of damages, physical scaling with strength, magical scaling with intelligence, brut ignoring everything and dealt after any calcul. # Section 13 - Advanced Damage Techniques ## 1 The Gameplay Effect Context We take a deep dive into the FGameplayEffectContext struct and see what it can do - and what it can't - An effect context is an object created for the effect containing many informations - instigator set when creating the context with an ASC - other things that we can modify at our will - an actor list - a hit result - a world origin - an ability - Context can be subclassed to add more informations to it - Add Ability in context when spawning projectile ability - Add hit result context in fireball hit ## 2 Custom Gameplay Effect Context We create our own custom Gameplay Effect Context struct - Create custom damage effect context containing critical hit and blocked hit informations ## 3 NetSerialize We look at NetSerialize and see what it does for serialization of the FGameplayEffectContext struct - The Archive type has an operator overloaded `<<` that works both way to serialize or deserialize - The function to serialize is the same as deserialize thanks to operator overloading ## 4 Implementing Net Serialize We implement NetSerialize for our custom Gameplay Effect Context struct - Copy of the implementation of parent net serialize because the serialization has to all happen in one step - Add our new variables to the bits ## 5 Struct Ops Type Traits We learn how Type Traits determine the capabilities of a Script Struct and we define Type Traits for our struct - there is a template struct TStructOpsTypeTraits bellow FGameplayEffectContext that we should use - Contains enum used by the reflection system to define behavior during serialization and replication - Copy the parent duplicate method ## 6 Aura Ability System Globals We create our own Ability System Globals class, which is necessary to designate our custom Effect Context to be used in our GAS project - Created a new class from ability system globals - override the allocate gameplay effect context to allocate our own type - Reference the custom effect context in DefaultGame.ini ## 7 Using a Custom Effect Context We learn how we can set and get the values of the variables in our custom Effect Context - Create method blueprint library to extract custom effect context from effect context handle - Create getter and setter to access custom property in blueprint - To not make a reference parameter being an output in blueprint, prefix it with `UPARAM(Ref)` ## 8 Floating Text Color We change the color of our Floating Text based on the values retrieved from our custom Effect Context - In aura attribute set, during post gameplay effect execute, Send effect context parameters to the player controller method that show a floating damage widget on the screen ## 9 Hit Message We add a Hit Message and set the text for it based on the values retrieved from our custom Effect Context - Add an animated text bellow the floating damage widget that animated with it according to the hit kind (critical or block) ## 10 Damage Types We define Damage Types with Gameplay Tags and create a Damage Gameplay Ability capable of dealing multiple damage types - Create additional gameplay tags for each damage type. brut, physical, magical, fire, ice, shock, shadow - make blueprint library function to get all damage gameplay tags - new intermediate class gameplay damage ability that contains a map of damages per types. Can assign set by caller magnitudes for all damage types in an effect spec handle - projectile actor has a list of applied effects handles ## 11 Mapping Damage Types to Resistances We add a map to our Gameplay Tags singleton so Damage Types are associated with Resistance to those Damage Types - Add attribute list for resistances and use it everywhere we use secondary attributes ## 12 Resistance Attributes We add Resistance Attributes to our Attribute Set - add the resistance attribute to the attribute set - Create a map in gameplay tags singleton to match damage effect type with damage resistance ## 13 Resistance Damage Reduction We reduce damage using our Damage Resistances - Make a function in blueprint to calculate base damage type against resistance - use the ExecCalc for damage to take resistance into calculs ## 14 Multiplayer Test We test our gameplay mechanics in multiplayer # Section 14 - Enemy AI 159 ## 1 Enemy AI Setup We discuss how our Enemy AI will behave - Must create a behavior three and controller and assign it to the enemy character ## 2 AI Controller Blackboard and Behavior Tree We create an AI Controller, a Blackboard, and a Behavior Tree for our AI Enemies - Add module `AIModule` to build - Create cpp ai controller class - contains behavior tree assignable in blueprint - run the behavior tree on possess - Create behavior tree and black board and assign it to enemy character ## 3 Behavior Tree Service We create a Behavior Tree Service to find the nearest player - Created a service FindNearestPlayer - Service can access `AIOwner` and `ActorOwner` - Service run bellow a task node while it's running - selector task run sub tasks until one succeeds ## 4 Blackboard Keys We add some Keys to our Blackboard - Add key for actor to follow and distance to actor - Add a key selector in the cpp service - the ticknode of find nearest player will lock for actor with tag of opposite team ("Enemy" <-> "Player") - Create editor object filter for selector keys using ``` virtual void OnNodeCreated() { TargetToFollowSelector.AddObjectFilter(this, GET_MEMBER_NAME_CHECKED(UBTService_FindNearestPlayer, TargetToFollowSelector), AActor::StaticClass()); DistanceToTargetSelector.AddFloatFilter(this, GET_MEMBER_NAME_CHECKED(UBTService_FindNearestPlayer, DistanceToTargetSelector)); } ``` ## 5 Finding the Nearest Player We create the algorithm for finding the nearest player - Pick the closest actor and set it in the blackboard key - Move to closest player actor ## 6 AI and Effect Actors We sort out compatibility issues with our AI and our Effect Actors - Uncheck use controller yaw in enemy character and use orient toward movement in character movement instead for a smooth rotation - Make potion actor picked up only by player ## 7 Behavior Tree Decorators We add Decorators to our Behavior Tree nodes to make them conditional - The course makes a decorator to check if we're a melee class ## 8 Attack Behavior Tree Task We create a Behavior Tree Task for Attacking - Created an attack task - Create a move around target task ## 9 Find New Location Around Target We give our melee attackers a way to find a new attack location close to their target - Move around the target to follow when reaching the desired range ## 10 Environment Query System We learn about the Environment Query System and how it can be used with AI - Generate set of points around actor with scores - Scores can be influences with parameters and custom logic ## 11 Environment Queries We learn how to create an Environment Query - There is an actor class EQSTestingPawn used to test environment queries - An eqs can generate geometric path around a target - Can be expensive so not to use too frequently ## 12 EQS Tests We learn how to run a trace Test on our Environment Queries - We can add a test to the generation of points to give values for each points - eqs have context class that we can customize by creating a blueprint from `EnvQueryContext_BlueprintBase` - contains functions that are used to determine points - used one to return all player controlled characters ## 13 Distance Test We learn how to perform a Distance Test on an Environment Query - Created eqs that check - grid of points in a walkable rectangle around - Prefer points far from enemies - Prefer points close to caster - Filter only points with visibility on enemy - defined ranged attack to be at 700 for now ## 14 Using EQS Queries in Behavior Trees We learn how to use our EQS Queries in our Behavior Trees - There is a behavior task to run query and set the best result in a blackboard key - Created behavior for mellee and ranged enemies - Created AIController for mellee and ranged - Assign correct behaviors to controllers and controllers to enemies # Section 15 - Enemy Melee Attacks 174 ## 1 Melee Attack Ability We implement the Attack Ability for melee attackers - Create ability for mellee attack ## 2 Attack Montage We create the Attack Montage for our melee Enemies - Create montage for goblin spear ## 3 Combat Target We learn how to set a Combat Target for our AI Enemies - Add target functionnalities in Combat interface ## 4 Melee Attack Gameplay Event We learn how to send a Gameplay Event to an Actor from an Anim Notify - Use anim notifications to trigger damage in ability ## 5 Get Live Players Within Radius We create a static utility function for getting all live players inside an invisible sphere of specified radius - Get sphere overlap for enemies of caster ## 6 Causing Melee Damage We implement causing melee damage of the Physical Damage Type - Use the hitdamage effect to apply damages to all overlapped enemies ## 7 Multiplayer Melee Test We test enemy melee attacks in multiplayer - Yup, it works ## 8 Montage Gameplay Tags We create Gameplay Tags for our Montage Events - Use a method in combat interface to get the correct montage to play from a name ## 9 Tagged Montage We create the concept of a Tagged Montage, or a Montage that is associated with a Gameplay Tag - Created struct that contains - the montage to play - the socket name tag to get when hit event happen - the hit event that will occur during the montage ## 10 Multiple Attack Sockets We handle the situation where an Enemy AI might have multiple attack sockets - Get the ability montage for the mellee ability and use the corresponding socket name and event to trigger the damage hit ## 11 Ghoul Enemy We create the Ghoul Enemy type - Create ghoul character. Warrior with slow move speed and lot of health ## 12 Ghoul Attack Montages We create Attack Montages for both left and right attacks for the Ghoul - Create attack montage for the ghoul ## 13 Melee Polish We polish up melee gameplay mechanics - Character movement has a section for avoidance so they avoid each other in groups # Section 16 - Enemy Ranged Attacks 187 ## 1 Ranged Attack We create the Ranged Attacker's Gameplay Ability - Created goblin ranged attack from projectile ability and add the ai auto attack tag ## 2 Rock Projectile We create the Rock Projectile that our Slingshot Goblin will launch - Create actor from projectile with a rotating static mesh for the rock projectile of slingshot ## 3 Ranged Damage Curve We create the Damage Curve for our Ranged Attacker - Add SlingshotHit in goblin ability damages curves and use it to define physical damages of the ability ## 4 Granting Ranged Attacks We grant the Ranged Attacker the Ranged Attack Ability - Give the ability to slingshot goblins ## 5 Slingshot Attack Montage We create the Slingshot Attack Montage - Create animation montage with ## 6 Playing the Ranged Attack Montage We play the Ranged Attack Montage in the Ranged Attack Ability - Link the montage to the combat ranged animation to play it in the ability ## 7 Spawning the Rock Projectile We spawn the Rock Projectile in the Ranged Attack Ability - Set the projetile of the ability to be the rock projectile and add rotating movement to the mesh - Add emissive color and smoke effect to the projectile ## 8 Slingshot Animation Blueprint We create an Animation Blueprint for the Slingshot Weapon - Create animation blueprint for slingshot - normal idle animation and default animation slot - modify the pouch bone with the location of the right hand socket of the character mesh ## 9 Slingshot Attack Montage We play an Attack Montage for the Slingshot when attacking - Animation blueprint has a boolean state of holding pouch bone - when firing animation, release the pouch bone and play the attack montage - when animation ends, hold the pouch again # Section 17 - Enemy Spell Attacks 196 ## 1 Goblin Shaman We create the Goblin Shaman Enemy type - Create shaman character with slow move speed - Create class data asset for goblin shaman and assign it - Assign hit react montage ## 2 Shaman Attack Montage We create an Attack Montage for the Goblin - Create attack animation montage - enable root motion in base attack animation - Setup combat sockets locations ## 3 Shaman Attack Ability We create the Goblin's Attack Gameplay Ability - Copy the slingshot ranged ability - set the animation tag to spell throw - projectile class to firebolt - damage type to magical fire - use new ability damage curve in goblin abilities - Add the ability to the class data asset ## 4 Dead Blackboard Key We make a Dead blackboard key so we can know when our Enemy is dead in the Behavior Tree - On enemy death, get the ai controller brain component and stop all logic ## 5 Enemies Multiplayer Testing We test out Enemy mechanics in multiplayer - We don't have bugs here # Section 18 - Enemy Finishing Touches 201 ## 1 Goblin Spear - Sound Notifies We add sound notifies for our Spear Goblin Enemy - Add souds for goblin and ghoul steps and attack ## 2 Impact Effects We add impact effects for when the Spear Enemy hits a target - Add particle effect when goblin ability hit ## 3 Melee Impact Gameplay Cue We learn how to create a Gameplay Cue to ensure that our hit effects replicate - Create a gameplay cue of type GameplayCueNotifyStatic - override function `OnExecute` to give a behavior when cue activates - create gameplay tag `GameplayCue.Impact.Spear` and assign it to the cue - execute gameplay cue with param on owner in the goblin spear attack impact - we can send many different parameters in the gameplay cue parameters structure ## 4 Montage and Socket Tags We introduce the concept of Socket Tags to our Tagged Montage - When getting the combat montage, we get a structure also containing informations about the hit socket and triggered gameplay tag ## 5 Goblin Spear - Hurt and Death Sounds We add Hurt and Death sounds to our Spear Goblin - Goblin have sound when hit and when dying ## 6 Goblin Slingshot - Sound Notifies We add sound notifies for our Slingshot Goblin - Rock has sound on impact - Add footstep sounds for goblin ## 7 Rock Impact Effects We add impact effects for our Goblin's slingshot rock - Slingshot impact trigger a particle system ## 8 Goblin Shaman - Sound Notifies We add sound notifies for our Shaman Goblin - Shaman sounds when walking and hurt ## 9 Ghoul - Sound Notifies We add sound notifies for our Ghoul - Add footstep sounds and death sounds for ghoul ## 10 Ghoul - Swipe Trail We create a swipe trail for our Ghoul attack - Ghoul attack have a trail effect ## 11 Demon Blueprint We create the Demon Character Blueprint - Create a new aura enemy for summoned demon ## 12 Demon Melee Attack We implement the Demon's melee attack - Create montages for demon melee attack with the spin animations - Create ability demon spin melee attack ## 13 Demon Ranged Attack We implement a ranged attack for the Demon - Create montage for demon ranged attack - Create ability demon throw projectile ## 14 Demon - Sound Notifies We add sound notifies to the Demon Character - Add sounds for demon footstep, hit reaction and death ## 15 Demon - Dissolve Effect We add the dissolve effect for the Demon's death - Setup dissolve effect in demon handle death ## 16 Shaman Summon Locations We create an algorithm to calculate summon locations for the Shaman - Create summon ability that find places to summon things ## 17 Async Spawn Times We use Timers to create Asynchronous spawn times for the Shaman's spawn Ability - For loop with delay to trigger each spawns ## 18 Summoning Particle Effect We implement a particle effect for summoning - Spawn summoning circle at each summoning locations ## 19 Select Minion Class at Random We create an algorithm to select a class to spawn at random - Pick random class from array and spawn it ## 20 Minion Summon Montage We implement the summoning montage for the Shaman - Create the shaman summon montage and assign it to the CombatMontage.Attack.Spell.Incant ## 21 Minion Count We implement a minion count - Assign a summoned minion list on the summon ability ## 22 Elementalist Behavior Tree We create a Behavior Tree for the Elementalist Enemy type - Add the summoning ability in the behavior tree ## 23 Elementalist Attack Task We create a Behavior Tree Task for the Shaman's Attack - The course does some weird shit ## 24 Decrementing Minion Count We decrement Minion count when a minion dies - Create function in summon ability to spawn character and manage the summoned minion list ## 25 Adding Juice with Tweening We add some Juice to the summoning of minions with Tweening - Add spawn effect on enemy characters ## 26 Enemies Final Polish We polish up the mechanics for our Enemies - May think about creating arc projectiles # Section 19 - Level Tweaks 227 ## 1 Level Lighting and Post Process We make our level look a great deal better with Post Process Effects - Level with a post process material that cancel eye adaptation - To cancel eye adaptation, use EV100 to 0, 0 ## 2 Texture Streaming Pool Over Budget We learn about the Texture Streaming Pool Over Budget error message, what it means and how to eliminate it. - Compress the 4k texture to take less vram ## 3 Flame Pillar Actor We create a Flame Pillar Actor and ensure that its light pulsates in a random manner - Use custom timeline to change light location and intensity for a burning effect ## 4 Fade Actor We create a Fade Actor which can fade out when obstructing the camera - Create static mesh class that can fade in and out - Create interface to fade in and out - Add capsule collision to the camera to fade interfering actors ## 5 Fading Out Obstructing Geometry We fade out obstructing geometry using our Fade Actor class - Player controller update on tick material parameter collection to define character and camera location - Create material function MF_CameraFade to return the opacity value of the fragment using parameter collection - Some materials can use it and link it to the opacity mask to automatically implement fading with camera - TODO: Implement a fading material for all assets # Section 20 - Cost and Cooldown 232 ## 1 Health Mana Spells Widget We create the Widget that will show Health, Mana, Spells, and XP - Update the widget overlay with a design to have vital attributes, abilities and xp bar - Create a widget containing health globe, mana globe, ability slots and custom named slots ## 2 Spell Globe We create a Spell Globe widget to show spell icons - Created a reusable widget for an icon in a ring - Created a subwidget to add a cooldown marker inside ## 3 Adding Spell Globes We add the Spell Globes to our Widget - Use the ability widget in the character widget ## 4 XP Bar We add an XP bar to our Widget - Create xp bar frame and progress and add it to the overlay ## 5 Ability Info Data Asset We create the Ability Info Data Asset that will store data related to Abilities - Create data asset for ability descriptions with name, description, icon and ring background ## 6 Initialize Overlay Startup Abilities We initialize the Startup Abilities in our Overlay so we can see the spell icons - Create a delegate in the Ability System Component to broadcast when ability are modified - Use the previous delegate in the Overlay widget controller to broadcast ability modifications using data from the data asset ## 7 For Each Ability Delegate We create a delegate that allows us to bind any functionality that we wish executed for each Ability in our Ability System Component - In ability system component, create a ForEachAbility function that iterate through all abilities and execute a lambda closure or a delegate - Need to call `FScopedAbilityListLock ActiveScopeLock(*this);` before the loop to lock ability from other tasks - Functions to extract ability id tag and input tag from ability spec ## 8 Binding Widget Events to the Ability Info Delegate We bind our Widget Events to the Ability Info Delegate Broadcast - When overlay widget receive a controller, dispatch it to all ability ring - Ability Ring will subscribe to the controller delegate for ability modification and check if its about them - Use `UAuraAbilitySystemComponent::OnRep_ActivateAbilities()` to broadcast ability change on client ## 9 Gameplay Ability Cost We implement Ability Cost for our Gameplay Abilities in the form of Mana - Create a cost effect for the firebolt 1. Create gameplay effect 2. Make it instant 3. Add a modifier Add for Mana Attribute 4. Use a negative value 5. Assign it to the effect cost of the ability ## 10 Gameplay Ability Cooldown We implement Gameplay Ability Cooldown - Create a gameplay tag for cooldown effects - Create a cooldown effect for the firebolt 1. Create gameplay effect 2. Effect grant gameplay tag cooldown `Ability.Cooldown.Fire.Firebolt` 3. Make it have a duration 4. Assign it to the effect cooldown of the ability ## 11 Cooldown Async Task We create an Async task capable of listening for changes to Cooldown Tags - Create a blueprint async task to watch over the cooldown - Send notification when receiving the cooldown effect with the duration - Send notification when cooldown tag is removed - Use it from the blueprint side to update visual cooldown ## 12 Cooldown Tags in Ability Info We add Cooldown Tags for each Ability in Ability Info - Make function from ability system component to get the cooldown tag from an ability - Add the cooldown tag to the ability info when broadcasting ability modifications ## 13 Showing Cooldown Time in the HUD We show an Ability's Cooldown in the HUD - Link the broadcast of the cooldown to UI ## 14 Modeling Mode We learn how to change the pivot points of meshes with Modeling Mode - K # Section 21 - Experience and Leveling Up 246 ## 1 Experience and Leveling Up We discuss ways to implement Experience and challenges that arise with it - Player has an experience count and the level is calculated by a curve ## 2 Level Up Info Data Asset We create a Data Asset to store info related to leveling up - Create data asset for leveling - float curve for xp required to each levels - array of reward for each levels ## 3 Adding XP to the Player State We add XP to the Player State class - Create LevelingExperience component to manage level and experience and add it to the player state ## 4 Listening for XP Changes We listen for XP delegate broadcasts - Broadcast changes from leveling experience in overlay widget controller to change the experience bar ## 5 Awarding XP Game Plan We discuss a plan to implement awarding XP - Incoming experience will be a meta attribute ## 6 XP Reward for Enemies We add an XP reward for various Enemy classes - Add the scalable float for death experience in the character class data info ## 7 Incoming XP Meta Attribute We create an IncomingXP Meta Attribute to handle incoming experience points - Add the meta attribute for incoming XP and observe modifications in the attribute set ## 8 Passively Listening for Events We create a passive Gameplay Ability that can listen for Gameplay Events - Create Passive ability (from `GameplayAbility`) that listen to event on activation - Create gameplay effect for event based effect - the event listenner ability will use the magnitude of received effect and use it in a based effect with the set by caller magnitude - Add passive ability to character class and grant and activate them when ability system is ready ## 9 Sending XP Events We send an Event for gaining XP - On fatal damages, send a gameplay event with a payload containing the experience to earn ## 10 Showing XP in the HUD We show XP in the HUD in our XP bar - Add PlayerInterface to fetch player informations from the avatar actor - Function to get the leveling experience component - On modification of meta attribute IncomingXP, get the leveling component and add the incoming XP to it ## 11 Level Up Interface Function We create a Level Up function in our Player Interface - The player state listen for level up in its leveling component ## 12 Leveling Up We implement leveling up - When leveling up, the player state will look for rewards and attribute them using a function overridable in blueprint ## 13 Showing Level in the HUD We show the level in the HUD as a globe widget - Create level widget from the ring icon and listen for level up changes to display the level ## 14 Level Up Niagara System We add a niagara system for leveling up - On levelup, player state will multicast an effect function ## 15 Level Up HUD Message We add a HUD message for level ups - On level up, overlay widget will display a message # Section 22 - Attribute Points 261 ## 1 Attribute Points Member Variable We add a member variable to the Player State for Attribute Points - Add replicated properties for attribute and skill points to a component added to player state - Create observer delegate for changes ## 2 Showing Attribute Points in the HUD We show the Attribute Points in the Attribute Menu - Add observing changes from the menu attribute widget controller - Add the number of attribute points to the attribute menu ## 3 Attribute Upgrade Buttons We make our Upgrade buttons functional in the Attribute Menu - Attribute modifier rows disable button when no available attribute points ## 4 Upgrading Attributes We implement upgrading Attributes - Clicking button will send a gameplay event of tag attribute - Event will be catch by a passive event listener and apply effect to add attributes ## 5 Top Off Our Fluids We fill up the Health and Mana globes when leveling up - Modifying Max Health or Mana will keep the health percent still - Leveling Up will restore full health and mana ## 6 Attribute Menu Polish We polish up our Attribute Menu - Add sound effect on button hover and click # Section 23 - Spell Menu 267 ## 1 Spell Menu Design We discuss the design of our Spell Menu, Spell Trees, and Spell Selection system ## 2 Spell Globe Button We create a new Widget for spell globe icons that functions as a button ## 3 Offensive Spell Tree We create the Offsensive Spell Tree ## 4 Passive Spell Tree We create the Passive Spell Tree ## 5 Equipped Spell Row We create the Equipped Spells row Widget ## 6 Spell Menu Widget We create the overall Spell Menu widget ## 7 Spell Description Box We add a scroll box for the spell description ## 8 Spell Menu Button We add a button to the Overlay to open the spell menu ## 9 Spell Menu Widget Controller We create the Widget Controller for the Spell Menu ## 10 Constructing the Spell Menu Widget Controller We construct the Spell Menu Widget Controller ## 11 Equipped Row Button We create the widget that functions as a button for the Equipped Spells Row - Create widget Selecting ability button - has an ability id tag - can be active and selected ## 12 Ability Status and Type We create a way to categorize Abilities by their status in the menu as well as distinguish between Offensive and Passive spells - Create status tag for ability info used to modify the button appearance and reactions ## 13 Showing Abilities in the Spell Tree We learn how to show the Abilities in the Spell Tree ## 14 Ability Level Requirement We implement an Ability Requirement for Abilities ## 15 Update Ability Statuses We update the Abilitiy Status when stats change ## 16 Updating Status in the Spell Menu We update the Ability Status in the menu ## 17 Show Spell Points We show the number of Spell Points in the Spell Menu ## 18 Selecting Icons We add the capability to select icons in the Spell Menu ## 19 Deselecting Icons We add the capability to deselect icons in the Spell Menu ## 20 Spell Menu Buttons We make the buttons that we will use to perform actions in the Spell Menu ## 21 Selected Ability We create a variable to keep track of the currently selected Ability ## 22 Spending Spell Points We add the capability to spend Spell Points ## 23 Rich Text Blocks We create styles for a Rich Text Block for our spell descriptions ## 24 Spell Descriptions We learn how to use the Rich Text Block for spell descriptions ## 25 FireBolt Description We implement the FireBolt spell description ## 26 Cost and Cooldown in Spell Description We show the Cost and Cooldown in the spell description's Rich Text Block ## 27 Self Deselect We implement the ability for a button to deselect itself ## 28 Equipped Spell Row Animations We create animations for the Equipped Spells Row ## 29 Ability Types We enforce Ability Types ## 30 Equipping Abilities We implement the capability to equip Abilities ## 31 Updating the Overlay When Equipping Abilities We update the overlay when an Ability has become Equipped ## 32 Globe Reassigned We handle the situation when a globe has been reassigned to a new Ability ## 33 Unbinding Delegates We unbind delegates to avoid duplicates # Section 24 - Combat Tricks 302 ## 1 Debuff Tags We create the Gameplay Tags we will use for debuffs - Create gameplay tag `Debuff`, `Debuff.Stun`, `Debuff.Slow`, `Debuff.Dot`, `Debuff.Attributes` ## 2 Debuff Parameters We create parameters that will configure a debuff - The course created a struct to have an appliable debuff with chance to apply and damage values ## 3 Damage Effect Params Struct We create a struct for all of the effect parameters for the Damage Gameplay Effect - The course created a function to apply a debuff struct to target actor. Creating an effect from the struct and assigning values with SetByCallerMagnitudes to it ## 4 Using Damage Effect Params We use the Damage Effect Params ## 5 Determining Debuff We determine whether or not Damage caused a successful debufff - Incoming damages sends an event to source actor with a payload containing the informations on the data. ## 6 Debuff Info in the Effect Context We add debuff variables to the Effect Context ## 7 Debuff in the Attribute Set We handle debuffs in the Attribute Set ## 8 Dynamic Gameplay Effects We learn how to create and apply Gameplay Effects dynamically in code. ## 9 Debuff Niagara Component We create a Niagara Component designed to handle debuff effects - Add delegate for actor death and ASC initialization ## 10 Death Impulse Magnitude We add a Death Impulse magnitude to our Damage Gameplay Effect ## 11 Death Impulse in the Effect Context We add the Death Impulse to the Effect Context - Add a HitImpulse vector to the custom effect context ## 12 Handling Death Impulse We handle the Death impulse on Character death - Die event get the dying effect parameter. - We use it to get the hit impulse of the killing effect. - We use the hit impulse to apply a force to a ragdoll body after death ## 13 Knockback We implement Knockback for Damage # Section 25 - What a Shock 315 ## 1 FireBolt Projectile Spread We generate the algorithm for multiple projectiles, spread by a specified angle - Add a math algorithm to the LibAmasson Plugin to generate points and transforms in an arc ## 2 Spawning Multiple Projectiles We spawn multiple projectiles with our FireBolt Ability - Fireball spawn multiple projectiles at higher levels ## 3 Homing Projectiles We implement homing projectiles - Fireball picks the hit actor from the hit result and set it as the homing projectile component ## 4 Click Niagara System We add a Niagara System for Click-To-Move - Rally point niagara effect when click to move is triggered ## 5 Invoke Replicated Event We learn about Invoking Replicated Events to send input data to the server - Send event to the ability when user press and release the ability input ```c++ // On Input Press AbilitySpecInputPressed(AbilitySpec); if (AbilitySpec.IsActive()) { InvokeReplicatedEvent(EAbilityGenericReplicatedEvent::InputPressed, AbilitySpec.Handle, AbilitySpec.ActivationInfo.GetActivationPredictionKey() ); } // On Input Release AbilitySpecInputReleased(AbilitySpec); if (AbilitySpec.IsActive()) { InvokeReplicatedEvent(EAbilityGenericReplicatedEvent::InputReleased, AbilitySpec.Handle, AbilitySpec.ActivationInfo.GetActivationPredictionKey() ); } ``` ## 6 Aura Beam Spell We create the class for spells which emit beams - Create ability blueprint and utilites ## 7 Electrocute Montage We create the Electrocute Anim Montage - Looping montage when channeling ## 8 Player Block Tags We create tags to block various capabilities in the Player Controller - Create gameplay tag to prevent some player event to occur ``` Player.Hide.Cursor; // When present, hide the player controller cursor Player.Block.AbilityInput; // When present, player will no longer try to activate abilities Player.Block.CursorTrace; // When present, the interaction controller will be deactivated ``` ## 9 GameplayCue Notify Paths We learn about the Gameplay Cue Notify Paths in our project and configure ours - Created a GameplayCueNotify_Static to play the sound of the shock ability - Use ExecuteGameplayCueOnOwner to play it To optimize the project, we can specify folders that contains our gameplay cues. ```ini # DefaultGame.ini [/Script/GameplayAbilities.AbilitySystemGlobals] +GameplayCueNotifyPaths="/Game/Blueprints/AbilitySystem/GameplayCues" ``` We can also specify a bigger number of RPC to call per frames (default is 2) ```ini # DefaultEngine.ini net.MaxRPCPerNetUpdate = 10 ``` ## 10 Gameplay Cue Notify Actor We learn about the Gameplay Cue Notify Actor version and create one - Created a GameplayCueNotify_Actor to spawn the shock niagara effect. - Use `AddGameplayCueOnActor (Looping)` to play it and `RemoveGameplayCueOnActor (Looping)` The `WhileActive` method is called even if someone joined after the begining of the effect. Whereas the `OnActive` only trigger once and can be missed by absent players. ## 11 Electrocute Looping Sound We use the looping sound for our Electricity - Add play looping sound on gameplay cue ## 12 Target Trace Channel We make the target trace channel - CursorHit Trace channel ## 13 First Trace Target We distinguish our first trace target - Do a line trace from the caster to the cursor point and get the hit target ## 14 Additional Targets We add additional targets to our Electrocute Ability - Get the N closests enemies actors around the impact in a range. ## 15 Shock Loop Cues on Additional Targets We add the Shock Loop Gameplay Cue to additional targets - Loop over all targets to apply shock cue ## 16 Electrocute Cost Cooldown and Damage We implement Cost and Cooldown for Electrocute - Create the Cost and cooldown effect for shock ## 17 Applying Electrocute Cost and Damage We apply the Cost and Cooldown for Electrocute - Apply the cooldown when using the ability and the cost at every tick of damages. 18 Electrocute Polish We polish up the Electrocute ability 19 Explode Dem FireBoltz We explode Fireballs if they haven't moved sufficiently for a time period 20 Stun We implement the Stun debuff 21 Stun Niagara System We add the Stun Niagara System 22 Shock Loop Animations We implement Shock Loop animations Section 26 - Passive Spells 337 1 Passive Spell Tags We create the Gameplay Tags for Passive Spells 2 Aura Passive Ability We create the Passive Ability Class 3 Passive Ability Info We add to Ability Info for Passive Abilities 4 Passive Tags in Spell Tree We add Gameplay Tags to the Passive Spell Tree 5 Multiple Level Up Rewards We implement multiple level up rewards 6 Passive Ability Activation We implement Activation of Passive Abilities upon Equip 7 Passive Niagara Component We create the Niagara Component for Passive Abilities Section 27 - Arcane Shards 344 1 Magic Circle We create the Magic Circle 2 Spawning Magic Circles We spawn a Magic Circle 3 Magic Circle Interface Functions We create interface functions for the Magic Circle 4 Arcane Shards Spell We create the Arcane Shards Ability 5 Wait Input Press We use Wait Input Press and learn how to make this work using Invoke Replicated Event 6 Anti Aliasing and Moving Decals We learn about different Anti Aliasing modes and how they interact with decals 7 Point Collection We create a Point Collection class for Arcane Shards 8 Async Point Locations We devise an Asynchronous algorithm to get point locations one after the other 9 Gameplay Cue Notify Burst We learn about the Gameplay Cue Notify Burst flavor of Gameplay Cues and how awesome it is 10 Arcane Shards Montage We implement the Arcane Shards spell montage 11 Radial Damage Parameters We create Radial Damage Parameters 12 Setting Radial Damage Parameters We set the Radial Damage Parameters 13 Radial Damage with Falloff We implement Radial Damage with a Falloff 14 Tying Radial Damage All Together We tie all of the components of Radial Damage together 15 Ignore Enemies while Magic Circle Active We ignore tracing against Enemies while the Magic Circle is active 16 Knockback Force and Death Impulse Overrides We implment Knockback Force and Death Impulse 17 Spell Descriptions We add spell descriptions to our Spell Menu 18 Section 28 - Fire Blast 363 1 FireBlast Ability We create the FireBlast Gameplay Ability 2 FireBlast Cost and Cooldown We implement Cost and Cooldown for FireBlast 3 Aura Fire Ball We create the Fireball ability for FireBlast 4 Spawning FireBalls We spawn the Fireballs for FireBlast 5 FireBall Timelines We create Timelines for the Fireballs to fly out and come back 6 Causing FireBall Damage We cause damage with the Fireballs as they pass through objects 7 FireBall Explosive Damage The Fireballs explode when coming back in, causing Explosive Damage 8 Empty Cooldown Texture We discover a bug when switching Abilities during Cooldown and fix it 9 Execute Local Gameplay Cues We learn how to execute Gameplay Cues locally, avoiding sending RPCs Section 29 - Saving Progress 372 1 Saving Progress We discuss the theory behind saving progress in games 2 Main Menu We create the Main Menu for our game 3 Play and Quit Buttons We add Play and Quit buttons to the Main Menu 4 Vacant Load Slot We create the Vacant Load Slot 5 Enter Name Load Slot We create the Enter Name Load Slot 6 Taken Load Slot We create the Taken Load Slot 7 Load Menu We create the Load Menu itself 8 MVVM We discuss the MVVM architecture pattern and its similarities and differences to MVC 9 View Model Class We create the View Model class 10 Constructing a View Model We construct our Load Screen View Model 11 Load Slot View Model We create a Load Slot View Model 12 Switching the Widget Switcher We switch the Widget Switcher 13 Save Game Object We create the Save Game object for the Load Screen Menu 14 Binding Variables to ViewModels We learn how to bind variables to a View Model 15 Load Slot Status We give the Load Slots their own status 16 Enabling the Select Slot Button We enable/disable the Select Slot Button 17 Enabling Play and Delete Buttons We enable/disable the Play and Delete Buttons 18 Are You Sure Widget We create the Are You Sure Widget 19 Deleting a Slot We implement Deleting Save Game Slots 20 Map Name Field Notify We create a Field Notify for the Map Name 21 Saving the Map Name We save the Map Name 22 Traveling to the Saved Map We implement traveling to a Saved Map Section 30 - Checkpoints 394 1 Choose Player Start We override the Game Mode's Choose Player Start function 2 Default Player Start We designate the Default Player Start when starting a new game 3 Saving the Player Start Tag We save the Player Start Tag for the next time we load in 4 Checkpoint We create the Checkpoint class 5 Save Progress Interface Function We save progress via an Interface function 6 Saving Player Data We save the Player's Data 7 Loading Player Data We load the Player's Data 8 Initializing Attributes from Disk We initialize our Attributes from Data loaded from disk 9 Showing Player Level in Load Screen We show the Player's Level in the Load Screen Menu 10 Saving Abilities We save Gameplay Abilities 11 Loading Abilities We load Gameplay Abilities 12 Data Structures for Saving Data We create Data Structures for saving an Actor's state 13 Saving World State We save the world!!! 14 Loading World State We load the world Section 31 - Map Entrance 408 1 Different Highlight Colors We implement different highlight colors 2 Highlight Interface We create a Highlight Interface so other objects can be highlighted aside from Enemies 3 Targeting Status We create a Targeting Status for the Player Controller 4 Highlighting Non-Enemies We highlight non-Enemy objects 5 Set Move-To Location We implement a way to override the Move-To location 6 Beacons We create Beacons 7 Map Entrance We create the Map Entrance class 8 Dungeon Stair Entrance We create the Dungeon Stair entrance 9 Dungeon Entrance Blueprints We create the Dungeon Stair Entrance Blueprint 10 Polish Menu We polish the Menu 11 Spawn Volumes We create a Spawn Volume class 12 Player Death We implement Player Death, respawning at the last save point 13 Loot Tiers We create Loot Tiers 14 Loot Effects We add effects to our Loot 15 Loot Drop Curve We create a Loot Drop curve 16 Pickup Sounds We implement pickup sounds 17 Quit Button We add a Quit Button to the Overlay Setion 32 - Course Conclusion 425 1 Quest - Levels We are tasked to design and create our levels for the game project 2 Conclusion Congratulations!!!