2052 lines
90 KiB
Markdown
2052 lines
90 KiB
Markdown
|
|
# 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<FLifetimeProperty>& 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<FMyType>(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<class UserClass, typename PressedFuncType, typename ReleaseFuncType, typename HeldFuncType>
|
|
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<AMyClass>(MyClass, SpawnTransform, OwnerActor, Cast<APawn>(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!!! |