Unreal Engine 5 C++: Advanced Action RPG

Set up the hero character with a basic class structure, input bindings using native gameplay text data asset and enhanced input, animation blueprint, and a custom ability activation policy.

Set up a warrior base game and base character, then create a warrior hero character and hero controller, compile, and configure maps and blueprint classes.

Create a warrior debug helper to print on-screen messages and logs in Unreal Engine 5 C++. Place the header in public and wire it into the hero character.

Set up a hero camera for a third-person action RPG in unreal engine 5 using a spring arm and follow camera, and configure capsule size, socket offset, and movement settings.

Create and manage native gameplay tags to map input actions, then build a custom input component and an input config data asset to bind inputs for gameplay abilities.

Create a data asset to map input tags to actions, define a warrior input action config struct, and configure move and look mappings in Unreal Engine 5 C++.

Create a custom Warrior Input Component by extending the enhanced input component and binding actions with modifiers via a template method. Configure project settings to use this component.

Learn to bind input in Unreal Engine 5 C++, using a data asset to set mapping context, implement move and look callbacks, and test in editor.

Build a multi-class character anim instance system in Unreal Engine 5 C++, creating base and hero anim instances, animation blueprint, and linked layers, with native initialize animation and update logic.

Create an unarmed locomotion animation blueprint with idle and jog states, using ground speed with max 400 and smoothing 0.2, then assign to hero, compile, and test in level.

Extend the hero anim instance in Unreal Engine 5 C++ by adding relax idle sequences and random transitions, using the animation blueprint to enhance unarmed locomotion.

Set up the Unreal Engine 5 gameplay ability system, create the warrior ability system component and attribute set, and enable weapon spawning for attack, block, and rolling.

Build a warrior gameplay ability in unreal engine 5 c++ with an activation policy, either on given or on triggered, activating when given to spawn weapons via ability system component.

Create a warrior weapon base class with a static mesh and collision box in Unreal Engine 5 C++, then subclass it to a hero weapon and prepare for spawning logic.

Script a gameplay ability to spawn a warrior weapon base, cast to the avatar, and attach the weapon to the character mesh socket with proper transform rules for equipping.

Define a startup data base asset and derived hero and enemy assets, then implement a grant-abilities workflow for the character's ability system component, organizing activated and reactive abilities.

Learn how to use soft references to a startup data asset and perform synchronous loading in C++, enabling reliable hero weapon spawn, while contrasting asynchronous loading for enemies.

This section sets up input binding with native gameplay tags and enables the character to spawn and attach a weapon via the gameplay ability system, preparing equip and swing next.

Develop a melee combo system in Unreal Engine 5, enabling light and heavy attacks, weapon equipping, animation montages, ability input, weapon data, and slow-motion with sound effects.

Implement weapon equipping and unequipping via new gameplay abilities, bind input actions, and build an animation-driven system for flexible light and heavy attack combos with finisher transitions and combo-based damage.

Learn to implement a pawn extension component base in Unreal Engine 5, derive hero and enemy combat components, and use templates to access the owner and controller for weapon spawning.

Register spawned weapons in the comeback component using a weapon map and a warrior gameplay tag, then expose blueprint-callable functions to register, retrieve by tag, and manage equipped weapon.

This lecture builds the hero gameplay ability as a child of the warrior base, adds helper functions to access the hero character, controller, and comeback component, and caches the reference.

bind native input actions to the hero's ability input actions via the input configuration and data asset, then implement and test the bindings in the warrior input component.

Bind input actions to the hero ability set by passing input tags to the ability system component, and grant those abilities via the hero startup data.

Bind an input action to abilities by creating callback functions in the hero character, passing the input tag to the ability system component, and activating the matching ability.

Trigger the weapon equip sequence by playing a montage via a gameplay ability, using an upper body slot and layer blend per bone (spine_01) to animate while preserving movement.

Learn to equip a weapon mid animation by awaiting a gameplay event, sending it via a notify, and attaching the weapon to the right hand socket.

Learn to use an animation layer interface to support multiple weapons with empty states, a master animation blueprint, and armed locomotion blended by the current equipped weapon tag.

Create and wire a master animation layer in Unreal Engine 5 C++, implementing interfaces and armed locomotion states, with a 1D blend space driven by ground speed.

Link the new animation layer to the hero weapon data in C++, wire structs and enums to the weapon system, and enable seamless weapon equipping and animation transitions.

Set up the default weapon ability for the axe by creating ability tags, a gameplay ability blueprint, and an input action, then use a montage and gameplay events to unequip.

Grant hero weapon abilities after equipping an axe by updating the warrior ability system component to grant two abilities via an input mapping context, with level control.

Learn to implement the axe unequip sequence by unlinking anim layers, removing granted abilities and input mappings, and reattaching the axe to the back socket.

Implement a light attack ability in Unreal Engine 5 C++, setting up blueprint assets, input actions, and granting the ability to unlock a weapon-based combo system.

Develop an animation‑independent light attack combo system in Unreal Engine 5 by selecting the actor instancing policy, mapping attack montages, and tracking a current combo count with a reset timer.

Implement and grant the heavy attack ability to the hero, with a proper parent class, input action, and right mouse button binding; verify by printing a debug message.

Implement heavy attack logic in Unreal Engine 5 by creating and playing attack montages, tracking the current heavy attack combo count, and using per actor instancing for two moves.

Explore building a Warrior Function Library in Unreal Engine 5 C++ to support a heavy-attack and light-attack combo system, using Blueprint Function Library, gameplay tags, and the Ability System Component.

Master a robust combo system in unreal engine 5 c++ for an action rpg by using gameplay tags to jump to finisher and manage light and heavy attack sequences.

Implement slow motion with an nm notify state and time dilation in Unreal Engine 5 C++, enhancing heavy and light attacks, and add weapon swing and grunt sounds to montages.

Wrap up this section by validating a robust combo system, preparing to add exciting combat features, and performing cleanup, adjusting the hero gameplay ability class, compiling, and testing assets.

Develop enemy characters in Unreal Engine 5, load startup data, equip starting weapons, set health and attack attributes, implement hit detection, damage calculation, combat feedback, and a ui binding system.

Address the core challenges of dealing damage and comeback feedback. Build enemy attributes, hit detection, and damage calculation that scale with combo, while updating UI and delivering hit effects.

Set up an enemy character by creating a warrior enemy character class, startup data asset, gameplay ability, and combat component, then compile and organize blueprints for future enemies.

Create the Gruntling Guardian enemy in Unreal Engine 5 by deriving from the base class, assigning its skeletal mesh and capsule, and establishing a template animation blueprint.

Learn to asynchronously load enemy startup data in Unreal Engine 5 C++, using the asset manager's streamable manager, binding a lambda callback, and granting enemy abilities from startup data.

Spawn a starting weapon for the guardian by creating a derived gameplay ability, selecting the weapon class and socket, tagging the weapon, and scaling it to fit the guardian.

Define and initialize health, rage, attack power, and defense power in an Unreal Engine 5 C++ attribute set, using helper macros and accessors to support gameplay ability system.

Explore creating and applying gameplay effects in Unreal Engine 5 to initialize a hero's attributes with curve tables and attribute-based calculations for max health, rage, attack power, and defense power.

Apply startup gameplay effects to self using the ability system component by looping startup gameplay effects, obtaining each effect's default object, and applying with the proper level and context.

Implement a pawn combat interface to access the pawn combat component and toggle weapon collision during attack animations, enabling precise hit detection in Unreal Engine 5 C++ action RPG.

Toggle weapon collision in Unreal Engine 5 c++ by creating a blueprint callable function and an enum to switch current equipped weapon or hands, with debug messages confirming enablement.

Bind weapon begin overlap events in Unreal Engine 5 C++, perform hostile target checks, and notify the combat component to enable correct damage in an action RPG.

Bind begin and end overlap delegates for the comeback component. Override two callback functions in the hero comeback component to handle hit target actor and weapon pulled from target actor.

Process a valid melee hit by tracking overlapped actors, preventing duplicates, and sending a shared_event_melee_hit gameplay event to the gameplay ability to apply damage after a montage.

Add a notify state toggle for weapon collision across light and heavy attack montages, enabling precise collision windows and tracking current attack type and combo count for damage.

Implement final damage using a gameplay effects back end, capturing attack type, combo count, and weapon base damage, then apply damage via gameplay effect execution and update ui attributes.

Implement a shared damage gameplay effect with a custom calculation class, link weapon base damage via a curve table, and apply attack type tags for hero damage.

Create native and blueprint functions to apply a gameplay effect spec handle to a target, using the ability system component, and return the active gameplay effect handle with a success status.

Capture relevant attributes in Unreal Engine 5 C++ by setting up a damage calculation that references the hero's attack power and the target's defense power using attribute capture definitions.

Override the execute function to capture attack power, defense power, base damage, and combo counts via set by caller tag magnitudes for final damage in Unreal Engine 5 C++.

Implement final damage calculation in Unreal Engine 5 C++ by scaling damage with light and heavy attack combos, applying attack power and defense, and updating a placeholder damage taken attribute.

Wire heavy attack damage in the heavy attack master blueprint using gameplay effects and weapon damage at the current level, and verify final damage with combo count and target defense.

Learn how to use the damage taken attribute to modify the current health attribute, clamp health between zero and max, and update the user interface during combat.

Define shared and enemy gameplay tags, create a hit react gameplay ability blueprint with event triggers and montages, grant the ability to guardian and enemies, then test combat feedback.

trigger the hit react ability by applying a hero damage effect and sending a gameplay event to activate the enemy's hit react, with blueprint handling target and optional facing rotation.

Implement heavy attack hit effects by using a material function to compute dissolve effects and a dynamic material instance controlled by a scalar parameter.

Add a hit pause visual cue by implementing a hitbox gameplay ability triggered by a gameplay event, using per-actor instancing and time dilation to enhance melee combat.

Add camera shake to combat by creating a camera shake asset and wiring it through the player controller, then tweak location, rotation, field of view, and timing.

Add hit reaction sounds to character montages using play sound notifications and volume tweaks. Then implement a concurrency asset to limit simultaneous hits to one by stopping the oldest sound.

Use gameplay cues to play the melee impact sound on hit in Unreal Engine 5 C++, creating a gameplay cue blueprint, tagging it, and executing it during attacks.

Develop enemy death in Unreal Engine 5 C++ by adding a death tag at zero health and triggering a death montage and effects via a gameplay ability, with testing.

Use a blueprint interface to notify enemy characters when a death ability ends, pausing animations, disabling collision, and playing particle and material effects before destroying the actor.

Learn to spawn dissolve Niagara effects for enemies in Unreal Engine 5, using soft object references, async load, dynamic material instances, and color parameters to synchronize edges with visuals.

Develop a universal pong UI component to sync health bars and icons for both players and enemies. Bind attribute changes through a dedicated interface to broadcast UI updates.

Broadcasts current health percent and current rage percent from the warrior attribute set to the UI using dynamic multicast delegates, caching the pong and hero UI components for reliable updates.

Set up widgets to listen for broadcasts from the ui component, binding to health and rage changes to update bars, while leveraging a warrior widget base that overrides on initialized.

Initialize and wire widgets created by enemy characters, bind to the enemy UI component, and expose blueprint callable events to reflect the current health percent in Unreal Engine 5 C++.

Create reusable template widgets for an action RPG UI by building a warrior size box, status bar, and health bar prototypes, and expose adjustable properties for runtime use.

Learn to set a health status bar fill color in Unreal Engine 5 by updating progress percent and choosing colors through percent thresholds, with editor previews and public variables.

Create a template icon slot widget in Unreal Engine 5 C++, implementing a size box, border, and image with a soft texture for runtime icon updates.

Learn to build a hero overlay widget in unreal engine 5 c++, adding a health bar, rage bar, and equipped weapon slot on a canvas panel with delegate bindings.

Attach an enemy health widget component to the enemy character, initialize it in begin play, and update its health bar percent from the enemy's health.

Hide the enemy health bar on startup and during death, reveal only while taking damage, toggle visibility in blueprint, and manage initialization with a timer and a first broadcast boolean.

Update the equipped weapon icon in the UI for Unreal Engine 5 C++ action RPG by broadcasting the icon texture through a dynamic multicast delegate and clearing it on unequip.

Fix the weapon icon flicker by manually loading the soft texture and updating it. Adjust health and ratio bars, move the equip weapon slot, and differentiate hero and enemy bars.

Wrap up this section by showcasing combat features from dealing damage to updating the UI, with code in C++ and Blueprint, and enabling light and heavy attacks for the hero.

Explore advanced AI in Unreal Engine 5 C++, adding avoidance, strafing, and melee behaviors with blueprint and C++ behavior trees, perception, and environment query system for dynamic combat.

Configure the enemy ai controller and behavior tree to manage multiple foes with avoidance, perception, and environment query system, enabling strafing and attack activation.

Override the path following component with the detour crowd following component to enable detour crowd avoidance, letting agents go around each other instead of pushing.

Configure ai perception with a sight config to detect enemies and ignore friendlies and neutrals. Tune sight radius and peripheral vision, and bind the on enemy perception update callback.

Implement generic team IDs and hostile/friendly attitudes via the AI generic team agent interface, applying them in warrior and hero controllers, and validate perception by printing sensed actors.

Create a behavior tree and blackboard to assign a target actor via AI perception, then move the AI to that actor with a move to task.

Tune AI avoidance in Unreal Engine 5 C++ by adjusting detour avoidance quality, debugging with visualizations, and tweaking project settings like max agent radius and velocity bias for combat-ready pathing.

Explore the four behavior tree node types: composite, decorator, service, and task, and learn to use selector and sequence nodes with blackboard values to update distance to the target actor.

build and test behavior tree branches using blackboard based conditions to switch between strafing and chasing, with observer aborts and a 600-unit threshold guiding branch aborts.

Develop a native Unreal Engine 5 C++ behavior tree service that orients toward the target actor during strafing, updating every frame with rotation interpolation and blackboard key handling.

Master the environment query system (EQS) in Unreal Engine, using point grid and point cone generators, x context, and tests to filter and score items for a behavior tree.

Learn to generate strafing locations around a target actor with Unreal Engine 5's EQS, and build a custom query context blueprint to drive AI perception and behavior testing.

Implement a custom behavior tree task in Unreal Engine 5 C++ to toggle strafing state for enemies, adjusting movement and applying gameplay tags to drive strafing animations and speed.

Learn to compute strafing direction for enemies in Unreal Engine 5 using C++, feeding velocity and base rotation into a strafing blend space, with helper tags for animation states.

Create the strafing blend space for the Guardian, configure locomotion direction and ground speed axes, assign walk and idle animations, then test in level and refine strafing transitions.

Compute enemy attack chance using a behavior tree decorator with random bool with weight to trigger attacks rather than strafing, and implement Beat Decorator_compute_success_chance with min and max success chance.

Use a dot product test to filter items behind the enemy by comparing the enemy forward vector to items in the xy plane, discarding items with angle difference below 0.45.

Create an enemy melee ability using the gameplay ability system, defining a base class, per-actor instancing, and montages, then grant two Guardian melee abilities and test with the gameplay debugger.

Activate abilities by tag with a blueprint callable c++ function that retrieves random activatable abilities. Use a behavior tree task to select a matching spec and activate via parent class.

Determine whether a target pawn is hostile by comparing generic team ID in a function library, enabling correct damage logic and hit detection between heroes and enemies.

Process a valid melee hit by checking overlapped actors, validating blocks, and notifying the gameplay ability blueprint via the ability system blueprint library with a melee hit event tag.

Build an enemy damage effect spec, construct its context, and apply gameplay effects to the target actor using a payload-driven damage value and a curve-based damage setup for testing.

Set up a guardian base damage curve in a curve table for both melee abilities, compile, and test with live coding and debug output to verify attack and defense values.

Learn to implement motion warping in Unreal Engine 5 C++, enabling rotation toward a target during melee montages and updating warp targets through the enemy behavior tree.

Set and update motion warp attack targets at runtime using a blueprint behavior tree service that updates warp targets from the blackboard, ensuring enemies adjust target location during attacks.

Build a native Unreal Engine 5 C++ behavior tree task that rotates an enemy to face a target, defining blackboard keys and instance memory, with setup and compilation steps.

Implement a native behavior tree task in Unreal Engine 5 C++ to rotate an enemy to face the target actor, using blackboard data and angle precision.

Build a melee attack branch in a behavior tree by rotating to face the target, using decorators and a timed wait, and activating the melee ability with cooldowns.

Create a custom behavior tree decorator to check gameplay tags, aborting branches when the enemy is under attack, and add a range check on the blackboard to govern melee defense.

Create a duration gameplay effect to tag enemies as under attack when damaged, automatically removing the tag after five seconds, with stacking rules and testing via the gameplay debugger.

Implement abort all logic in a behavior tree to halt enemy actions when health reaches zero or target dies, using a show abort all logic decorator and blackboard keys.

Add guardian attack sound effects by integrating the weapon swinging, shouting, and weapon head sounds into the melee attack montage and triggering them with a gameplay cue.

Create reusable custom behavior tree services, decorators, and tasks for guarding and combat, enabling enemies to approach and melee attack, while implementing hit reactions, death, rolling, blocking, and target locking.

Implement directional rolling with motion warping to compute distance, and derive the react direction via dot and cross products. Add block and target lock using input actions and mapping.

Plan ahead by prototyping directional abilities, rolling, directional hit, react block, target lock, and hero death using a dummy guardian and a modified behavior tree to streamline development.

Implement a two-key input action (eight directions with spacebar) to trigger a rolling ability in Unreal Engine 5, detailing input tags, ability blueprints, and granting the roll to the hero.

Determine the rolling direction from the last movement input using motion warping, update the rolling montage rotation, and test the hero's roll in level with input-based control and careful timing.

Dynamically compute rolling distance using motion warping and a notified state. Update the world target from the line trace impact point and test with a hardcoded distance.

Use a scalable float curve in hero stats to determine rolling distance by level, reading values with a helper function get value a level in the blueprint.

Add rolling sound effects using new notify tracks and play sound actions, selecting ground and rolling assets. Preview and test in the level to fine-tune timing before continuing.

Develop the hero hit react ability in Unreal Engine 5 by creating the hit react blueprint and montages, granting it to the hero, and triggering it with gameplay events.

Grant and trigger the hero hit react ability by sending a hit react event tag and payload to the actor, testing montage playback during enemy attacks.

Add hero hit effects by applying a compute effects material to the hero's mesh, create and tweak a material instance, and drive the effect via the hit react ability.

Compute the hit react direction by measuring the angle between hero's forward vector and enemy, using dot product and cross product to determine left or right for montage selection.

Learn to implement directional hit react tags in unreal engine five by computing angle differences to select front, left, right, or back reactions and montage to play.

Switch on gameplay tag in blueprint selects ending montage (front, left, right, back) to play, while the animation blueprint blends upper and lower body when idle for a full-body montage.

add sound effects to hero hit reactions by inserting notify play sound events in hit react montages (front, left, right, back) using the sc character_hit sound, then test in level.

Implement the hero block ability, held input cancels on release, loops the block animation, and spawns a shield while active. Set gameplay tags, input actions, and bind to left shift.

Build a block ability in Unreal Engine 5 C++, looping the block montage and spawning a magic shield attached to the owner using a Niagara system and gameplay cues.

Explore how to determine a valid block in Unreal Engine 5 C++, by checking blocking state, validating with forward vectors, and leveraging perfect blocks for counterattacks.

Send a gameplay event to the hero on a successful block, define a player_event_successful_block tag, and respond in the hero's gameplay ability to play a montage and spawn a shield.

Handle successful block by orienting the hero toward the attacker and applying backward root motion, then trigger a magic shield gameplay cue with sound and impact particles.

Determine if a block is perfect by elapsed time since activation against a 0.25-second threshold, then show a green perfect or red normal cue signaling a parry for six seconds.

Notify the player of a perfect block by triggering a gameplay cue with the magic shield perfect block tag, spawning a refraction burst, and applying a brief global time dilation.

Implement a counterattack after a perfect block by adding a jump to finisher tag, timing the reset with a 0.3-second timer, and managing global time dilation during the block.

Set up a toggleable target lock ability in Unreal Engine 5 using C++ to handle activation and input policy, while updating the lock widget and rotation each frame.

Implement a toggleable target lock by handling the input tag to activate or cancel the ability, then grant GA_target_lock when equipped and map IA_target_lock to the middle mouse button.

Learn to obtain all available targets to lock by performing a box trace around the hero, configuring distance and box size, and storing results for locking.

Select the nearest target to log by evaluating available actors, using gameplay statics to find the closest, store it as the current locked actor, and cancel if none.

Design and render a target lock widget in Unreal Engine 5 using C++. Create the widget (size box, overlay, target icon) and add it to the viewport.

Project the locked actor's world location to screen space and position the target lock widget in the viewport, accounting for its size, then update its position each frame.

Create an ability task to tick each frame in a gameplay ability, updating the target log widget position and smoothly orienting the hero toward the target using a tick delegate.

Update target lock tick position widget and hero facing the locked actor using a blueprint callable function and delta time, canceling the ability if the actor is invalid or dead.

Orient the hero to the locked target when not rolling or blocking by interpolating the look-at rotation with target lock interp speed and applying it to the controller and actor rotation.

Switch to target lock poses by creating a plane space asset and a directional locomotion blend space, then drive animation blueprint with a boolean blend using target lock tag.

Learn how to control target lock walk speed in Unreal Engine 5 C++ by adjusting the character movement component's max walk speed and caching the default speed.

Learn to implement a switch target input action for target lock in Unreal Engine 5 C++, using mouse input to switch targets with dedicated callbacks and a unique mapping context.

Create and override a target lock mapping context in Unreal Engine 5 C++, implementing init and reset functions, subsystem access, and hero controller validation to prevent crashes.

Capture mouse input to determine the switch direction. Notify the target log ability with a gameplay event to switch targets left or right.

Implement and refine the target switching system by obtaining available actors to lock, sorting by left and right position using vector math, and selecting the nearest target to lock.

Implement a hero death in Unreal Engine 5 using the Gameplay Ability System by creating GA_hero_death, configuring montages and sounds, and handling collision, input, and ability grants.

Fix crashes in target lock by adding an early return, and improve camera visibility during target lock by offsetting the look at rotation pitch with a camera offset distance.

Test hero combat abilities—directional rolling, hit reaction, blocking, and target lock—against cloned enemies, adjust guardian stats, and test balance, noting the need for stronger foes in the next section.

Create a ranged enemy that shoots projectiles and defends with unblockable melee attacks. Define starting weapon, stats, combat abilities, design shooting-position ux, and implement projectile class and damage.

Reuse the guardian framework to create a ranged enemy with a starting weapon, curve table, and projectile ability, then adjust its behavior tree and animation blueprint.

Create a curve table for Glaeser starting stats, including attack power, defense power, max health, and base damage across levels; then create and assign a startup gameplay effect and test.

Add a health bar UI for the Glazer in screen space, create material instances with dissolve effects for the Glazer and its weapon, and implement a Glazer death effect.

Fix rolling warp near walls with a blocking-hit check and impact point for motion warp. Build a ranged enemy with a glacier AI controller and a copied guardian behavior tree.

Construct a behavior tree to find shooting position using a selector, sequence, decorators, and blackboard keys, then run an x query to locate shooting projectile location and move to it.

Learn to create a projectile ability in Unreal Engine 5, including a reusable projectile class, damage logic for players and enemies, and associated vfx, activated via the behavior tree.

This lecture explains how to spawn a glazer projectile from a gameplay ability using an animation notify, socket location, and spawn transform, including instigator setup and testing with speed adjustments.

Tune projectile spawn and collision box, position the Niagara component, bind on component hit and begin overlap delegates, test with debug prints, then destroy the projectile on impact.

Handle projectile hits by casting to a pole, validating hostility, and destroying non-hostile hits; detect blocking, trigger successful block, and spawn impact effects and sounds via blueprint.

Create an effects backend in the projectile class and apply a gameplay effect spec handle to the target on impact to damage it.

Create the projectile damage handle with the enemy damage effects handle and GE shared deal damage, map a projectile damage scalable float to a curve table (10,12,14,16), and test damage.

Add and wire projectile sound effects, including the spawn sound and flying sound, attach them to the projectile, and configure muzzle effects with spawn system using the actor forward rotation.

Create a glacier melee ability blueprint, add a glacier melee montage with a weapon trail, and trigger it in the enemy behavior tree when the hero is within 250 units.

Learn to make a melee attack unblockable by adding an enemy status tag, checking it in the enemy combat component to ignore blocking, and triggering gameplay cue with warning vfx.

Refine the behavior tree and melee attack timing for a melee and ranged enemy, then test on a dedicated combat test map with adjustable materials.

Add an admin enemy that shoots projectiles at the hero, runs away, and launches an unblockable melee attack with a ranged enemy; tease a boss fight in the next section.

Create a boss in Unreal Engine 5 with a boss bar, melee attacks, and minion summons, implementing skeletal mesh, starting stats, combat abilities, hand collision boxes, and asynchronous spawning.

Set up a frost giant boss by creating a blueprint, assigning a skeletal mesh and animation blueprint, and configuring a 1D blend space for locomotion, adjusting capsule size, then previewing.

Fix the giant's shadow by switching to shadow maps in project settings. Define stats with a frost giant curve table for health, defense, and attack, and organize assets in folders.

Create a boss health bar widget by adding a template text block and boss bar, arranging an overlay with a status bar and boss name, binding health changes to percent.

Create a boss bar widget, set the boss name, and add it to the viewport to draw the health bar on screen.

Refine the frost giant boss by adjusting its health bar material for more detail and create a giant hit react gameplay ability, then test in level.

Create and wire a frost giant death ability, including an ending montage, a death sound, and a dissolve effect, then test the boss combat changes.

Remove the boss bar on boss death by updating the enemy UI component and its drawn widgets, registering and removing widgets via blueprint functions.

Create a frost giant AI controller and its behavior tree, using a sequence with a move to task, test at 200 radius, and set max walk speed to 120.

Build a giant melee attack by creating an ability blueprint and montage, adding sounds and trail effects, and integrating motion warping in the giant's behavior tree.

Configure left and right hand collision boxes using UBoxComponent, enable collision, and bind begin overlap to handle damage for the giant boss in the engine.

Override post edit change property to attach left and right hand collision boxes to the corresponding hand bones using editor exposed bone name variables.

Unreal Engine 5 c++: toggle box collision enables hit detection for boss hand collision boxes and routes damage handling through the enemy combat component, using left and right hand collisions.

Create the frost giant's second melee ability with a new end montage and adjusted anim notifies, enabling root motion and unblockable versus blockable attacks via spawn offset parameters.

Add the frost giant's third melee combo by creating an end montage, configuring anim notifies and sounds, and aligning motion warping and ground marks for a two-handed attack.

learn to implement a wait spawn enemies ability task for the frost giant boss, using a soft reference and tweakable spawn origin and radius to spawn enemies via blueprint.

Create the ability text and ending montage for the summon enemies, assign the ability to the boss, and test the setup.

Listen for the gameplay event tag from the enemy montage to trigger spawning, then asynchronously load the soft enemy class for spawning in a custom ability task.

Learn to asynchronously load enemy classes and spawn multiple guardians using the asset manager, streamable manager, and navigation system to generate random spawn points and proper rotations.

Fix the facing rotation for spawned enemies by replacing the cached spawn rotation with a rotation from the boss's forward vector using avatar actor forward vector, and apply motion warping.

Hide the enemy health bar on startup and fix async startup loading. Fade in the enemy and weapon meshes with a reverse dissolve timeline and a configurable entry restore time.

Create and play enemy entry montages in Unreal Engine 5 using blueprints, assign entry montage addresses, and add sounds for guardians and bosses to enhance entry effects.

Create a custom health percent decorator in the behavior tree to trigger boss summoning when health falls below a threshold, using the ability system to query current health percent.

Explore implementing reachability, special weapon abilities, activation conditions, and rage-based effects; create an ability blueprint, icon widget, and latent actions, then implement heavy and healing stone mechanics for action RPG.

Create a rage-driven hero with invincibility, implement rage progression and cooldown-based special weapon abilities, and add healing and rage stones that spawn from defeated enemies.

Create a rage ability blueprint for hero, configuring the rage status tag and attack cancellation. Bind rage to left control when the axe is equipped and test with print messages.

Create and manage the rage montage by adding gameplay tags, playing a montage with root motion, and blocking other abilities during activation.

Fix rage entry effects by hiding the starting weapon after spawn using the dissolve amount parameter. Trigger rage VFX via gameplay cues and event tags, then clean up on end.

Set up activation and ongoing checks for the hero rage ability, toggle invincibility with gameplay tags, and validate conditions by updating attribute logic and tag-based state transitions.

Create an infinite rage cost gameplay effect, link it to hero rage via a tag and curve table, and apply it in the ability graph, removing it when rage ends.

Create a rage slash projectile in a blueprint, integrate niagara visuals, adjust collision, and configure impact and spawn sounds to enhance hero attacks in the rage state.

Spawn the rage slash projectile after validating the rage state, using a custom event to spawn the projectile at the weapon socket and align rotation with the hero's forward vector.

Adjust the rage slash to use on begin overlap, enabling it to damage multiple enemies, while implementing overlapped actors tracking, hostility checks, and applying projectile damage with gameplay event data.

Set up light and heavy attacks to spawn the rage slash projectile by sending gameplay events from each montage and configuring the ability blueprint for rage activation.

learn to implement an instant rage gain effect that increases the hero's current rage after every successful melee attack, using level-based curves and a dedicated gameplay effect.

Demonstrates granting a special weapon ability in Unreal Engine 5 C++, by adding a special ability set, icon material, cooldown tag, and wiring it into the hero weapon data.

Create the light ability montage, wire the play montage action, and add sound, slow-motion, and trail notifies with a weapon trail socket.

Set up light ability to apply melee damage via ending montage, using a weapon collision notify state from frame five to frame twelve and wiring damage in ability blueprint.

Create a cooldown gameplay effect using hedge duration and a curve table tied to weapon stats to manage weapon ability cooldowns.

Create and integrate an ability icon widget into the hero overlay with a cooldown text. Update and adjust visibility and sizing to reflect equipped weapons and cooldown states.

Broadcast on ability icon slot updated delegate from the hero UI component to refresh the icon when a weapon is equipped, passing the ability input tag and ability icon material.

Listen for ability icon changes by wiring the owning hero UI component delegate to per-slot ability input tags, asynchronously load assets, and update icons on equip and unequip.

Learn to bind a dynamic multicast delegate for ability cooldown, broadcast cooldown data to the user interface, and display and hide the cooldown text on the ability icon.

Implement a custom latent action named countdown to update ui text and play the material animation, using a blueprint function library for construction and a native delay action for logic.

This lecture demonstrates building a native c++ countdown action class for unreal engine 5, initializing variables, handling remaining time and update intervals, and wiring output pins for a latent action.

Construct a native latent countdown action in the warrior function library using the latent action manager to add or find the action, wiring update interval and start and cancel inputs.

Override the update operation for the custom latent countdown action, handle cancellation, and emit the cancel or finished pins while tracking elapsed time against the total countdown.

Update the widget by using map range clamp to remap remaining time from total cooldown to 1–0 and drive the material animation with a dynamic icon material instance.

Add a blueprint-callable C++ function to query remaining cooldown by tag using the gameplay ability system, then resume and display cooldown in the UI on weapon equip.

Add a heavy weapon ability via a gameplay ability blueprint, enable invincibility during activation, configure input actions and bindings, grant it to the hero, and test in the level.

Build a heavy ability montage by adding anim notifies, sound cues, slow motion, and Niagara effects, then test and adjust in level gameplay.

Apply heavy ability damage by performing a box trace to identify multiple hit results and feed the hits into a new blueprint callable function using gameplay events and tags.

Trigger a gameplay event to start AoE damage, then use a multi trace box from the hero's location and forward vector, 200 units long, to apply damage.

Duplicate the existing cooldown gameplay effect, rename it for the heavy ability, and define a new cooldown curve (levels 1-4: 45, 43, 41, 39), then wire it to the ui.

create healing stones as pickups that heal health and rage, using a warrior stone base derived from a pickup base, with collision detection, overlap handling, and spawning by dead enemies.

Create a blueprint base for stones, add a Niagara visual component, and build child blueprints for healing and rage stones with a configurable total stone amount.

Create a hero pickup stones ability in Unreal Engine 5 C++, automatically activated on stone overlap, displays a pickup UI, and consumes stones only after the input key is pressed.

overwrite on begin overlap for stone pickup, cast to warrior hero, access its ability system component, and activate the pickup ability using the stones gameplay tag.

This lecture implements a per-frame box trace to detect and collect stones into an array, casting to warrior stone base, and cancels the ability when no stones are overlapped.

Implement a native input action to pick up stones, detect multiple stones, and trigger a consume stones event via gameplay tags; test with a debug message.

Implement stone consumption in Unreal Engine 5 C++, wiring the consume stones function to the gameplay ability, applying a stone gameplay effect and triggering blueprint events for VFX and sound.

Finish the stone consumption logic by spawning effects, playing sounds, and destroying the stone, then set up healing and rage stones with gameplay effects, curves, and user interface prompts.

Create an on-screen input key widget in Unreal Engine 5 to show the consuming stones key, update the text at runtime, and toggle visibility near stones.

Create a dynamic multicast delegate to show or hide the input-key widget when overlapping stones, wiring it through the hero UI component from the C++ gameplay ability.

Set up blueprint logic to listen for an input action, display the stone interaction UI, and show the mapped key name using the enhanced input system.

Define an enemy spawn stone tag and build a base and guardian spawn stone abilities, then activate the enemy spawn stone ability after enemy death to trigger a test message.

Implement spawn stone logic in Unreal Engine 5: trace to the floor, select a random navigable location, and spawn healing or rage stones via asynchronous class loading.

Duplicate guardian spawn stone to glacier, create glacier stone spawn chance curve with levels, assign in the gameplay ability, update reactive abilities, and test for balanced spawn rates.

Test the hero against the boss, adjust hero stats and rage costs, and verify rage and weapon abilities. Finalize a functional game loop with start, win, lose, and end states.

Create a survival game mode that spawns enemies in waves, using a test map and data table for wave counts and total enemies, with C++ wave logic and blueprint widgets.

Create a survival game mode that spawns enemies in waves, tracks win or loss, and displays a winning or loot screen; set up a test map to verify wave spawning.

Implement a survival game mode class in C++ with a state enum and a dynamic multicast delegate, then bind the delegate in blueprint to drive state transitions.

Create a data table driven enemy wave spawner by defining an F warrior enemy wave spawner info struct with a soft enemy class pointer and per-spawn counts.

Learn wave progression logic in Unreal Engine 5 C++, derive total waves from a data table, and manage countdowns to spawn new waves and complete all waves.

Create a wave countdown widget in Unreal Engine 5 C++ for an action RPG, expose the current wave count to blueprints, and animate and display the countdown text.

Learn to create and display a wave countdown widget in Unreal Engine 5 using blueprint, update its text content, start a counter, and clamp negative times to one.

Create a wave info widget to display the wave count, add a fade-out animation, and trigger enemy spawns after the widget disappears by enabling tick in the survival game mode.

Preload the next wave enemies by asynchronously loading their soft class pointers from the enemy wave spawner data table and store them in a preloaded enemy class map.

Spawn wave enemies in Unreal Engine 5 C++ using target points as spawn origins. Retrieve target points with gameplay statics, spawn warrior enemies at navigable locations, and manage wave counts.

fix enemy spawn in Unreal Engine 5 C++, using a dynamic multicast delegate to detect enemy destroyed and spawn waves for an advanced action RPG until the wave completes.

Implement and test wave completion by displaying a wave completed widget with a countdown, green color, and counters for remaining and total spawned enemies as waves progress.

Add more waves in the data table, include a single frost giant boss, test wave progression, and fix the glacier entry montage by adjusting the behavior tree wait times.

Register spawned enemies by exposing a blueprint callable function, loop through enemies, increment spawned counter, bind to on destroyed, cast to survival game mode, and trigger last wave widget.

Fix the boss spawn timing by aligning the wave countdown with the entry and fade-out animations, adjust the spawn enemies delay time, and implement the last-wave widget via blueprint rewrite in survival mode.

Trigger the survival game mode state change upon death, display a red player died message, pause animations, disable collisions, and set input to ui only; test confirms the message appears.

Implement a four-tier game difficulty in Unreal Engine 5 C++, creating a blueprint enum and adjusting hero and enemy ability levels based on difficulty.

Verify game difficulty by testing easy and very hard modes, confirming hero and enemy stats (max health, attack power, defense power) and damage against curve table values with debug messages.

Fine tune combat by expanding waves and adjusting enemy spawns in the data table, using the Grandline Guardian and frost giant, then test difficulty and prepare widgets.