1 Right Click in Content Browser -> Blueprint Class.

2 Search for SoulsCharacterBase in the All Classes list.

3 Open the new Blueprint and go to Class Defaults.

1Create BP_SoulsCharacter and set the parent class to SoulsCharacterBase.

2Assign DefaultMappingContext, movement, look, dodge, attack, block, lock-on, and sprint actions.

3Assign MobileHUDClass on the player controller and DamageTextClass on the character.

4Set the default pawn in BP_SoulsGameMode.

1Create BP_Sword_001 from SoulsWeaponBase.

2Set AttachSocketName to RightHandSocket.

3Assign light, heavy, charge, block, and dodge montages when available.

4Call EquipWeapon from the character Blueprint begin play or from a loadout system.

1 Open Project Settings -> Maps & Modes.

2 Set Game Instance Class to BP_SoulsGameInstance.

3 Critical: If this is not set, the persistence system (Chests, Souls, Inventory) will not save to disk.

1 Use MainMenu as the first level for the packaged demo.

2 Show WBP_MainMenu at level start.

3 Assign WBP_LoadingScreen on BP_SoulsGameInstance.

4 The menu automatically opens a new game map or continues from the saved map, then restores save data after loading.

Station Setup

• Place a BP_SoulsCraftingStation in the level.
• Assign your Recipes to the Recipes array.
• Set the Station Display Name (e.g., "Blacksmith Anvil").
• Assign WBP_SoulsCrafting to Crafting Widget Class.

• No Selection: only RecipeNameText remains visible with Select Recipe. Details, icons, feedback, progress, and the craft action remain hidden or disabled.
• Recipe Selected: the details panel shows the icon, description, comma-separated requirements, visual ingredient list, result, Souls cost, and craft action.
• Missing Requirements: pressing Craft without enough items displays English feedback such as Missing required items or a missing-item summary.
• Long Details: place the detail content inside DetailsPanelScroll with clipping enabled so long descriptions and ingredient lists scroll inside the panel instead of overflowing the UI.

• Start: the system validates ingredients and Souls, consumes them at start, stores the pending result, and shows ProgressBarTime plus TextTime.
• In Progress: closing the UI does not cancel crafting. Reopening the same station restores the selected active recipe and current remaining time.
• Blocked Second Craft: trying to start another recipe while one is active returns feedback such as Crafting already in progress.
• Completion: the pending result is added once, selection is cleared, progress/time widgets are hidden, and non-repeatable recipes are marked completed.

• [ ] Naming: Is the button in the row named SelectButton?
• [ ] Binding: Is the row widget class assigned in WBP_SoulsCrafting defaults?
• [ ] Selection: Does clicking a row update the icon, details, requirements, result, and cost?
• [ ] Requirements: Does RequiredItemsText display ingredients on one line with commas, and does RequiredItemsList show ingredient icons and quantities?
• [ ] Feedback: Does missing inventory show clear feedback instead of crafting for free?
• [ ] Timed Craft: Does a timed recipe show progress and remaining seconds only after Craft is pressed?
• [ ] Reopen UI: If the UI is closed during timed crafting, does reopening restore the active recipe and remaining time?
• [ ] Save/Load: If saved during timed crafting, does load resume or complete the craft without duplicating the result?
• [ ] Non-repeatable: Does a non-repeatable recipe disappear or become unavailable only after successful completion?

1 In the Content Browser, create a Blueprint class from CameraShakeBase.

2 Use a Wave Oscillator Camera Shake Pattern for simple melee impact shake.

3 Start with short values such as Duration 0.12 - 0.20, Blend In 0.02, and Blend Out 0.06 - 0.10.

4 Assign the shake asset to the relevant Combat Feel Preset.

5 Test in PIE and reduce amplitude if repeated hits feel noisy.

• [01] Initial Impulse Multiplier

  The "Pop" driver. Explodes the character in the input direction. Note: Scales both Physics and Root Motion. Recommended: 3.0.

• [02] Continuous Force Multiplier

  Prevents slowing down during the animation. Essential for "sliding" dodges or long lunges. Recommended: 0.5 - 1.0.

• [03] Ground Friction Override

  Controls the glide distance after the initial launch. Lower values (1.5) create a smooth, buttery slide. Higher values (10.0) cause a dead stop.

• [04] Rotation Speed Override

  The steer-rate during the roll. Allows the player to change direction slightly while moving. Set to 50+ to give the player control.

• [05] Reset Velocity at Start

  Toggles StopMovementImmediately(). Essential for balance, ensuring consistency regardless of player speed.

• [06] Enable IFrames

  Safety first. Turns on damage immunity for the duration of the notify box. Frame-perfect protection.

• [07] Trigger FOV Kick

  Toggles cinematic camera zooming to emphasize the "Kick" and impact of the dash.

• [08] FOV Kick Intensity

  How far the camera expands. Use 10 - 15 for a powerful, high-action feel.

Directional Logic

• Joystick Input: The character will dodge in the exact world-space direction indicated by the joystick, relative to the camera and target.

• Neutral Input (Backstep): If no movement input is detected while locked-on, the character will perform a Backstep (dodging directly away from the target).

• Dynamic Montage Timing: The system automatically detects when the dodge animation (Montage) ends. Facing logic is suspended for the exact duration of the roll, preventing the character from snapping back to the enemy mid-animation.

• Smooth Recovery: Immediately after the dodge ends, the character enters a dedicated recovery state to smoothly rotate back and face the threat, avoiding "jittery" transitions.

Dodge-Attack Gating

To maintain high visual fidelity and prevent animation blending artifacts, the system enforces a strict relationship between dodging and attacking. This ensures that defensive maneuvers are not accidentally interrupted by aggressive inputs, while still allowing the player to escape danger at any time.

• [ ] Attack -> Dodge: Press Attack, then immediately press Dodge. The dodge should start and cancel the attack animation.
• [ ] Dodge -> Attack: Press Dodge, then spam Light/Heavy attack during the roll. No attack should trigger until the character has fully finished the dodge and returned to Idle.
• [ ] Dodge -> Ability: Press Dodge, then press the Weapon Ability button. The ability should not fire.
• [ ] Stamina Integrity: Verify that blocked inputs do not consume stamina or trigger cooldowns.

The Calculation

Delta = (CurrentTouch - LastTouch) * Sensitivity * DeltaTime

Instead of tracking a "joystick center", we track the frame-to-frame difference of your finger move. This allows for unlimited swipe area, meaning the player can move the camera regardless of where their finger starts on the right half of the screen.

The Stamina Cycle

Stamina is the most important currency in a Souls-like. Our component handles this with a Dual-Stage Regeneration system:

• Action Window: Regeneration stops for 1.2s (configurable) after any action (Dodge/Attack).
• Regen Stage: Stamina fills linearly at 25.0 points per second.
• Exhaustion: If Stamina reaches 0.0, the character enters "Exhausted" state where Sprint and Dodge are disabled until it reaches 20%.

Overview

The Targeting System controls the player's lock-on target, camera focus, target marker, and lock-on dodge behavior. It is designed for mobile Soulslike combat where the player needs fast target acquisition, predictable switching, and stable camera recovery without adding a separate targeting component.

1 Enemy Tagging: Ensure any actor you want to target has the Tag Enemy added to its Actor Tags. If the actor has a Souls stats component, dead targets are ignored automatically.

2 Input Mapping: Bind an Input Action (e.g., IA_LockOn) to the LockOnAction property in your Character's SoulsEngine|Input category.

3 Component Config: In the SoulsCombatComponent, set your desired LockOnRadius, LockOnBreakDistance, scoring weights, switch threshold, and marker settings.

Setup Requirements

1 Create a Widget Blueprint inheriting from SoulsLockOnTargetWidget (e.g., WBP_SoulsLockOnTargetMarker).

2 Add a UImage child named exactly MarkerImage. This is where your reticle texture goes.

3 Enable Is Variable on MarkerImage so the C++ widget class can tint and animate it.

4 Assign your Widget class to LockOnWidgetClass on the player's SoulsCombatComponent in your Character Blueprint.

1 Open your player Blueprint, select CombatComponent, and search for LockOnWidgetClass.

2 Set LockOnWidgetClass to WBP_SoulsLockOnTargetMarker.

3 Keep bShowLockOnTargetMarker enabled.

4 Start with LockOnMarkerDrawSize around 64 x 64 or 80 x 80.

5 Use LockOnMarkerWorldOffset to place the marker over the enemy body. A useful first value is a positive Z offset such as 0, 0, 80.

6 Leave LockOnMarkerSocketName empty for root attachment, or set it to a valid mesh socket such as head or spine_03 when your enemy skeleton provides one.

1. Smart Combo System

Our combo system is Data-Driven. You don't write logic for each swing; instead, the system reads the AttackMontage from your weapon and follows a strict naming convention for sections:

• Attack_1, Attack_2, Attack_3: Standard light attack sequence sections.
• Heavy_1, Heavy_2: Dedicated heavy attack sections.

The ComboCount variable tracks the current state and automatically jumps to the next section if the player clicks within the Combo Window.

2. Input Buffering System (BufferedAttack)

The most critical feature for "Souls-like" responsiveness. Instead of ignoring clicks during an animation, the system Buffers (stores) the next intent and executes it at the earliest valid frame.

• Logic: When an attack is triggered while bIsAttacking is true, the system checks the EBufferedAttack enum.
• Queuing: If you spam Light Attack, it stores a Light buffer. If you press Heavy Attack mid-swing, it overwrites with a Heavy buffer.
• Execution: The AllowCombo notify triggers the ExecuteBufferedAttack() function, checking if a strike is queued.

3. Mixed Combos (Light-to-Heavy)

You can now perform seamless transitions. For example, starting with 2 Light Attacks and finishing with a devastating Heavy Strike.

4. Advanced Charge Attack System v1.1

Heavy attacks can now be "Charged" by simply holding the attack button. This creates a high-reward tactical opening during combat. Everything is pre-configured to work with your existing Input Actions.

• How it works: The system automatically detects a "Long Press". If released early, a standard Heavy Attack plays. If released after the "Glow" (VFX), the devastating Charge Strike is executed.
• Power-Up: Use the ChargeDamageMultiplier to make these hits deal 2x or 3x damage.

Animation-Driven Parry Finisher Current

Successful parries do not kill the enemy immediately. The system stores the enemy as a pending parry target, plays the enemy's parried reaction, then waits for the player's Souls_ParryImpact notify inside the Counter Montage.

• Parry Success: enemy attack damage is cancelled before it reaches stats.
• Pending Target: the parried enemy is saved on the player's combat component.
• Impact Notify: Souls_ParryImpact applies Parry Finisher Damage at the visual hit frame.
• Authoritative Rules: The Kill Enemy On Successful Parry setting is now fully authoritative. It overrides any difficulty preset behavior, ensuring that if it is disabled in the editor, the enemy will always receive damage instead of being instantly killed.
• Fail-safe: if the notify is missing, Parry Impact Fail Safe Delay applies the finisher so testing does not get stuck.

Block Stagger

When blocking heavy attacks that exceed the BlockStaggerThreshold, the character will play a BlockStaggerMontage. This prevents "Tanking" everything and forces the player to manage their position.

Shield Break (Stamina Guard)

Every blocked hit consumes stamina based on the damage received. If stamina reaches zero, the character enters the ShieldBroken state and plays the ShieldBreakMontage, leaving them vulnerable to critical hits.

Parry Counter

Successfully performing a parry can play the configured Counter Montage. Put Souls_ParryImpact inside that montage to choose the exact frame where the enemy receives finisher damage.

Step 1: Weapon Defense Configuration

Character defense is configured primarily on the player's CombatComponent. Weapon block montages can still be used as advanced per-weapon overrides, but the clean player-project setup is under Souls | Character | Defense and Souls | Character | Parry.

• Block Montage: assign a looping defense montage on the CombatComponent.
• Parry Montage: assign the short guard/parry attempt animation.
• Counter Montage: assign the finisher montage and add Souls_ParryImpact at the hit frame.
• Block Damage Reduction: A value between 0.0 and 1.0 (e.g., 0.8 for 80% protection).

Step 2: AnimGraph - Upper Body Blending

To allow the player to move while blocking, we use Layered Blend Per Bone. This separates the defensive pose from the locomotion (walking/running).

Step 3: Character Defense Stats

In your Character Blueprint CombatComponent, you can fine-tune the global defense behavior:

• Use Parry When Block Starts: makes the Block input begin with a parry attempt before falling back to normal blocking.
• Active Parry Window: how long the incoming hit can be caught as a parry.
• Parry Impact Fail Safe Delay: backup timing if Souls_ParryImpact is missing from the counter montage.
• Block Stagger Threshold: If an incoming hit deals more damage than this value, the character will play the BlockStaggerMontage.
• Shield Break Montage: This montage plays automatically when the player's stamina reaches zero while they are holding the block button.

The "Perfect" Notify Sequence:

• 0.0s - 0.2s: Wind-up (Preparation).
• Souls AN Enable Hitbox: Place during the active hitting frames. (Notify State).
• Souls AN Allow Combo: Place during the recovery. Triggers Buffered Inputs.
• Souls AN Reset Combat: Place at the very last frame to clear the strike queue.

[Action] Souls AN Allow Combo

Internal Class: USoulsAN_AllowCombo

Logic: When the animation playhead hits this frame, the system calls ExecuteBufferedAttack(). If the player clicked earlier, the next attack starts immediately.

[State] Souls ANS Combat Trace AAA UNIFIED

Internal Class: USoulsANS_Hitbox

Logic: This is the "Gold Standard" for combat registration. It performs a Frame-to-Frame Sphere Trace between the previous and current positions of two sockets, ensuring a continuous damage volume even during sub-frame movement.

Visual Debugging: Enable bShowDebug within the Notify to see the spheres in real-time. This can be toggled per-animation to assist in fine-tuning without polluting the global game view.

[Action] Souls AN Hitstop

Internal Class: UAnimNotify_SoulsHitstop

Logic: Triggers a brief global time dilation effect to simulate "Impact Weight". Essential for the AAA feel.

[AI] Advanced Combat Tactics PRO

The AI now utilizes a probability-based decision engine to switch between light and heavy strikes.

• Heavy Attack Chance: Configurable per-enemy. Allows AI to break player guards and vary attack patterns.
• Boss Aggression: Bosses automatically receive a 60% cooldown reduction and high-priority heavy strike queuing.

[Action] Souls AN Reset Combat

Internal Class: USoulsAN_ResetCombat

Logic: Resets ComboCount to 0 and clears BufferedAttack. Essential at the end of every montage to prevent "Stuck" input states.

• Option A (Static Mesh): In your Weapon Blueprint, click +Add -> Search for StaticMesh. Drag it under WeaponMesh to parent it. Set your sword model here.
• Option B (Skeletal Mesh): Simply select the WeaponMesh component and assign your Skeletal Mesh directly in the details panel.
• [NO HITBOX NEEDED]: You no longer need to add Box/Capsule collisions for damage. The system uses the Sockets on your mesh directly via the AnimNotify.
• Important: Ensure the model is rotated correctly so it aligns with the character's hand in the viewport.

Attack Montage: The primary data source for Light Attacks. Ensure sections are named Attack_1, Attack_2, etc.

Heavy Attack Montage: (New) A dedicated montage for Heavy Attacks.
• If assigned: System uses sections from this montage (e.g., Heavy_1).
• If empty: System falls back to the primary Attack Montage and searches for "Heavy" sections.

Locomotion BlendSpace: (Optional) Providing a BlendSpace here allows the character to change their idle/walk/run animations based on the weapon (e.g., dragging a Greatsword vs holding a Dagger).

Dodge Montage: You can assign a unique dodge for specific weapons (like a 'Quickstep' for daggers).

Skeleton Flexibility: Montages no longer require matching skeletons. You can assign any animation montage to any character or weapon regardless of their base skeleton, provided the core bone names match (e.g., standard Humanoid setup).

Hit Effect Assign a Particle System (Cascade or Niagara). This will spawn at the impact point (e.g., Blood burst or sparks).

Hit Sound Assign a Sound Wave or Cue. This plays a "thud" or "slash" sound when the hitbox overlaps an enemy.

1. Weighted Scoring Selection

Unlike basic systems that only pick the closest enemy, the lock-on scan uses configurable scoring to determine player intent:

• Distance Score: Prioritizes immediate threats based on physical proximity.
• Camera Center Score: Prioritizes enemies closest to where the player is looking.
• Line of Sight: Optional trace check that prevents targets behind solid objects from being selected.

2. Polished Target Switching

Designed for touch screens. While locked on, a quick swipe on the right side of the screen triggers a Directional Switch.

• Input Deadzone: Switches only trigger if LockOnSwitchMinInput is exceeded, preventing accidental cycles during camera adjustments.
• Switch Cooldown: A short cooldown prevents switching through multiple targets in a single swipe.
• Validation: The system automatically skips dead or invalid targets during the switch search.

3. Intelligent Target Validation (Auto-Clear)

The system constantly monitors the state of your target to ensure the camera never stays "stuck" on empty air or dead corpses:

• Death Monitor: If the target's StatsComponent reports IsDead(), the lock-on clears instantly.
• Distance Break: If the player or target moves beyond LockOnBreakDistance, the camera releases focus to prevent snapping.
• Marker Cleanup: Guaranteed destruction of VFX/Widget components upon target loss, preventing "ghost" indicators.

Simple Combat AI Fallback Recommended First Test

The default enemy can now chase, face, and attack the player without requiring a Behavior Tree or NavMesh setup. This is the recommended first setup for testing damage, parry, hit reactions, and death flow in the showcase map.

• Enable Simple Combat AI: keep bEnableSimpleCombatAI enabled on BP_SoulsEnemyBase.
• Use Behavior Tree: keep bUseBehaviorTree disabled for the basic enemy. Enable it only when you want the advanced BT-driven enemy.
• Training Dummy: enable bIsTrainingDummy to stop AI movement and keep the enemy useful for damage and parry testing.
• Aggressive Enemy: disable bIsTrainingDummy, assign a default weapon, and place the enemy within SimpleDetectionRadius.

Current build also includes ready Blueprint parent classes: SoulsTrainingDummyEnemy for damage/parry testing and SoulsAggressiveEnemy for a fast showcase opponent. Create a Blueprint from either class, assign mesh, animation data, and weapon, then drop it into the showcase map.

AI Ability Selection PRO

Enemies can use a modular, data-driven ability system to execute special attacks based on weight, range, and cost. This system operates as a priority layer above the standard light/heavy combat fallback.

• Modular Data Assets: Create a SoulsAIAbilityDataAsset to define each move.
• Advanced Logic: Includes AbilityId, Weight, MinRange, MaxRange, Cooldown, and StaminaCost.
• Interrupt Behavior: Configure if the ability can be interrupted by damage or if it grants "Hyper Armor" during execution.
• Repeat Policy: Use Can Repeat Ability, Min Repeat Interval, Avoid Immediate Repeat, and Repeat Penalty Multiplier to prevent boring loops without blocking the only valid ability forever.
• Boss Phase Lists: Bosses can assign a different AIAbilities list inside each entry of the Boss Phases array, while normal enemies can keep using the global AIAbilities list.

Ability Repeat & Movement Policy Advanced

AI abilities now expose practical behavior controls directly on the ability data asset, letting designers tune whether an enemy repeats a move, lunges into range, or commits to a full animation before choosing the next action.

• Can Repeat Ability: allows the same ability to be selected again after its cooldown and repeat interval.
• Min Repeat Interval: adds a repeat-specific delay separate from the base cooldown.
• Ability Repeat Memory Count: enemy-level memory used by weighted selection to avoid repeating the same ability too often.
• Ability Movement Mode: supports dash, leap, or lunge-style movement depending on the configured mode.
• Ability Movement Timing: lets movement happen before the montage or during the montage.
• Desired Strike Distance: lets lunging abilities stop at an attack distance instead of standing exactly on top of the player.

Data-Driven Boss Phases PRO

Bosses can use a flexible Boss Phases array instead of a fixed two-step setup. Each entry defines when that stage begins, which abilities it uses, and what transition feedback should play.

• Health Threshold: Use normalized values such as 1.0, 0.66, and 0.33 to build one-stage, two-stage, or three-stage encounters.
• Phase Display Name: The current label is shown in the Boss HP HUD, for example Guardian, Enraged, or Final Stand.
• AI Abilities: Assign a different ability list per stage so the boss changes behavior as health drops.
• Transition Feedback: Optional montage, sound, and VFX can play while movement and AI decisions are paused.

Telegraphed AI Abilities PRO

Special attacks can include readable windups (Telegraph) and recovery delays. This improves combat readability and prevents AI from chaining powerful moves instantly.

• Windup Time: A configurable delay before the montage begins. Ideal for "roar" or "weapon glow" cues.
• Recovery Time: A post-execution pause that ensures a window of opportunity for the player.
• Events: Bind to OnAIAbilityTelegraphStarted for visual/sound cues and OnAIAbilityRecoveryStarted for posture changes.

Boss Resistances & Immunities PRO

Configure advanced physical and status resistances to create formidable boss encounters. These settings allow bosses to ignore standard player interactions like parries or staggers.

• Immune to Parry: Blocks parry finishers and stun states entirely. Perfect for giants or heavy-armored bosses.
• Immune to Stagger: Prevents hit reaction montages, allowing the boss to power through player attacks (Hyper Armor).
• Knockback Resistance: Scales or negates physical impulse from heavy attacks and explosions.
• Status Resistance: Multiplier for status effect buildup (e.g., Poison, Bleed), making the boss harder to afflict.

Enemy Difficulty Presets New

Enemy Blueprints can now auto-apply a clean preset from AIDifficulty. This keeps setup fast while still producing distinct gameplay roles for basic enemies, elites, bosses, and testing dummies.

• Auto Apply Difficulty Preset: enabled by default. The enemy applies its preset at BeginPlay.
• Preset Can Override Stats: lets the preset set HP/stamina values.
• Preset Can Override Tactics: lets the preset set combo count, cooldown, heavy chance, strafe, retreat, and enrage.
• Apply Difficulty Preset: Blueprint-callable node for manually refreshing the enemy after changing difficulty.

Planned Enemy Combos & Action Commitment PRO

The simple enemy AI builds a short attack plan when it reaches combat range. Light and heavy attacks are protected by an action owner so the AI does not start an animation and immediately replace it with an ability or another attack.

AI Debug Logs Optional

Enemy debug logs are disabled by default to keep the project clean. Enable them only while tuning or investigating enemy behavior, then turn them off again before normal playtesting.

• Enable: open the enemy Blueprint or placed enemy instance, then turn on Show Simple AI Debug Logs under Souls > Enemy > AI > Debug.
• Runtime Blueprint: call Set Simple AI Debug Logs Enabled if you want a debug button in your own test tools.
• Read the log: search for SoulsAI in Output Log. Useful messages include Chasing target, Attack requested, Starting light combo plan, Starting standalone heavy attack, and Attack blocked: cooldown.

Combat Strafe & Retreat New

When the enemy is close to the player but waiting for attack cooldown, it can now circle-strafe instead of standing still. After a combo or heavy attack, it can also step back briefly to create a more readable Souls-like rhythm.

• Use Combat Strafe: enables side movement while the enemy is inside combat range.
• Combat Strafe Chance: controls how often the enemy chooses to circle instead of holding position.
• Post Attack Retreat Chance: controls how often the enemy backs away after an attack plan.

Low Health Enrage New

Enemies can become more dangerous when their health drops below a threshold. Enrage increases attack speed and reduces cooldown, giving bosses and elite enemies a simple phase-two feel without requiring a complex state machine.

• Enable Low Health Enrage: turns the feature on or off per enemy.
• Enrage Health Percent: health percentage where enrage activates.
• Enraged Attack Speed Multiplier: controls how fast attacks play after enrage.
• Enraged Cooldown Multiplier: lowers attack cooldown after enrage.

Spawn Leash Return New

The enemy can now return to its original spawn point if it is pulled too far away. This keeps the showcase map stable and prevents enemies from chasing forever across the level.

• Use Spawn Leash: enables return-to-spawn behavior.
• Leash Radius: maximum distance from spawn before the enemy disengages.
• Return Acceptance Radius: distance from spawn where the enemy is considered back home.
• Reset Stats When Leashed: optionally restores HP/stamina when the enemy returns.
• Immediate Reacquire: after returning home, the AI polls for the player again instead of waiting for a new overlap event.

Identity & Corpse Cleanup Professional UI

Defining an enemy's role and its lifecycle after death is now centralized in the Enemy|Identity and Enemy|Death categories. This ensures consistent behavior across all enemy types.

• Is Training Dummy: Disables normal AI aggression and turns the actor into a test target. Dummies use the Enemy|Respawn logic instead of cleanup.
• Is Boss: Identifies the enemy as a boss, enabling boss-specific HUD integration and phase logic found in Enemy|Identity.
• Corpse Cleanup Delay: Found in Enemy|Death. Controls how many seconds a normal enemy corpse remains before removal. Set to 0 to keep the corpse indefinitely.
• Respawn Delay: Found in Enemy|Respawn. Specifically controls training dummy restoration intervals.

Showcase Mode (Cinematic)

Designed for developers and content creators. When enabled (bShowcaseMode = true), the AI transforms into a cinematic movement actor.

• Zero Aggression: All combat logic is bypassed. The AI will never attempt an attack.
• Fixed Cinematic Distance: AI maintains a strict 650-unit radius for optimal camera framing.
• Intelligent Repulsion: If the player approaches, the AI smoothly backpedals to restore the cinematic distance.
• Focus Maintenance: AI remains permanently focused on the player actor.

1 Create a SoulsAIAbilityDataAsset in the Content Browser.

2 Assign a Montage and set MinRange / MaxRange values.

3 Enable Use Telegraph and set Windup Time (e.g., 0.5s) and Recovery Time (e.g., 0.3s).

4 Configure repeat behavior with Can Repeat Ability, Min Repeat Interval, and optional repeat penalty settings.

5 Configure Ability Movement Mode only when the ability needs dash, leap, or lunge movement.

6 Configure Impact Tuning if this ability needs unique damage, knockback, guard damage, poise damage, or hit reaction behavior.

7 Assign a Combat Feel Preset if this ability needs unique hitstop, camera shake, sound, VFX, block, or guard-break feedback.

8 Open your Enemy Blueprint and add the asset to the AIAbilities array.

9 Ensure Use AIAbility Selection is checked in the enemy defaults.

Advanced Behavior Tree Tasks

For developers using the Behavior Tree (BT) system, several custom C++ tasks are provided to handle complex Souls-like movement and combat logic.

What This System Adds

The player now owns a SoulsInventoryComponent. It supports item stacks, equipment slots, weapon equip, quick consumable use, pickup actors, and save snapshots through the existing save system.

• Item Data: create SoulsItemDataAsset assets for weapons, consumables, key items, and soul currency.
• Inventory: add, remove, find, and count item stacks from Blueprint.
• Equipment: equip a right-hand weapon from inventory and update the combat weapon automatically.
• Quick Item: assign a consumable to the quick slot and call Use Quick Item to heal and consume one stack.
• Pickup: place SoulsItemPickup in the level for overlap-based item rewards.
• Enemy Drops: add loot entries on enemies so they spawn pickup actors on death.
• Save: inventory stacks, right-hand weapon, and quick item are saved in SoulsSaveGame.

Quick Setup: Weapon Item

1 Create a Data Asset from SoulsItemDataAsset.

2 Set Item Type to Weapon.

3 Assign Weapon Class to your weapon Blueprint, for example BP_Sword.

4 Add the item to the player's SoulsInventoryComponent.

5 Call Equip Inventory Item on the player, or Equip Item on the inventory component using RightHandWeapon.

Quick Setup: Healing Item

1 Create a SoulsItemDataAsset and set Item Type to Consumable.

2 Set Max Stack to a value such as 10.

3 Set Heal Amount to the HP restored per use.

4 Add it to inventory, call Equip Quick Item, then call Use Quick Item.

Playtest Checklist: Inventory and Pickup

This is the fastest way to confirm the full item loop before building a final inventory UI.

1 Create DA_Item_Sword from SoulsItemDataAsset, set Item Type to Weapon, and assign your sword Blueprint to Weapon Class.

2 Create DA_Item_Heal, set Item Type to Consumable, set Max Stack to 10, and set Heal Amount to a value such as 40.

3 Create BP_ItemPickup from SoulsItemPickup, assign DA_Item_Heal, set Quantity to 3, and keep Pickup On Overlap enabled.

4 Place BP_ItemPickup in the map and walk over it. If the actor disappears, the item was added to the player's inventory.

5 For a weapon test, add DA_Item_Sword to InventoryComponent and call Equip Inventory Item. The weapon should spawn and attach to the character hand socket.

6 For a healing test, add DA_Item_Heal, call Equip Quick Item, take damage, then call Use Quick Item. HP should increase and the stack should decrease by one.

Enemy Loot Drops

Enemies can now spawn item pickups when they die. This gives the showcase a real reward loop after combat.

1 Open your enemy Blueprint, for example BP_SoulsEnemyBase or an aggressive enemy Blueprint.

2 In Souls > Enemy > Loot, keep Drop Loot On Death enabled.

3 Set Loot Pickup Class to your visual pickup Blueprint, for example BP_ItemPickup. If empty, the system uses the base SoulsItemPickup.

4 Add entries to Loot Drops. For each entry, assign an Item, set Quantity, and tune Drop Chance from 0.0 to 1.0.

5 Kill the enemy. A pickup should spawn near the death location and can be collected by walking over it.

Advanced Item Configuration

Upgrade your SoulsItemDataAsset with professional rules for a deeper RPG experience.

• Weapon Grip: toggle between OneHanded and TwoHanded. 2H weapons automatically unequip the left hand.
• Equip Side: restrict weapons to Right Hand Only, Left Hand Only, or Either Hand.
• Action Rules: per-item flags for bCanBeDropped, bCanBeUsed, and bCanBeEquipped.
• World Drop: assign a DroppedPickupClass and DroppedPickupMesh so dropped items respawn as collectable pickups.
• Paired Offhand: one-handed weapons can optionally define a paired shield, spell book, or secondary weapon.

Drop Confirmation System Mobile Safe

Protect rare and important items from accidental deletion with the mobile-first drop confirmation system.

• bRequireDropConfirmation: enable this in any SoulsItemDataAsset to force a popup before dropping.
• ConfirmationDialogClass: assign your confirmation widget Blueprint in the WBP_SoulsInventory details.
• Safe Behavior: Closing the inventory or tapping Cancel preserves the item. Only a deliberate Confirm tap executes the drop.
• Mobile Priority: Optimized for touch with clear, large buttons and safe input restoration.

Key Items & World Unlock

Key items can now be configured to unlock specific world objects like doors or gates without building a full quest system. The key stays as normal inventory data, while the world object decides which key it accepts.

• bCanUnlockWorldObjects: enable this for items that act as keys.
• bConsumeOnWorldUse: if true, the key is removed from inventory after one successful use.
• UnlockId: an optional ID (e.g., Gate.CourtyardKey) that must match the door's RequiredUnlockId.
• Recommended key rules: set important keys to non-droppable, non-equippable, and non-usable from the inventory action bar.

Inventory UI Foundation PRO

The backend inventory system is fully upgraded. The UI handles categories, dynamic action buttons, and professional equipment rules natively.

• Tabs: All, Weapons, Consumables, and Key Items.
• Details: selected item name, description, type, quantity, and icon.
• Equipment: current right-hand weapon, left-hand weapon, and quick item readouts.
• Actions: dynamic English labels: Equip / Unequip / Switch / Use / Drop.
• Input: closing the inventory should restore the current developer playtest input mode, including visible cursor in Mobile UI Test mode.

WBP_SoulsInventory Layout Skeleton Built

The first Blueprint layout pass creates the inventory window structure without final styling. This gives C++ and Blueprint a stable set of widget names to bind before the real item entries are generated.

1 Create WBP_SoulsInventory with parent SoulsInventoryWidget.

2 Add InventoryRootPanel and InventoryMainBox as the centered inventory window.

3 Add a header with InventoryTitleText and SoulsCountText.

4 Add tab buttons: TabAllButton, TabWeaponsButton, TabConsumablesButton, and TabKeyItemsButton.

5 Add InventoryContentBox as a horizontal three-column area: ItemsPanel, DetailsPanel, and EquipmentPanel.

6 Add the item lists: ItemsList, WeaponsList, ConsumablesList, and KeyItemsList. Keep ItemsList visible and the category lists collapsed until tab switching is wired.

7 Add details widgets: SelectedItemIcon, SelectedItemNameText, SelectedItemTypeText, SelectedItemQuantityText, and SelectedItemDescriptionText.

8 Add equipment readouts: RightHandWeaponText, LeftHandWeaponText, and QuickItemText.

9 Add ActionButtonsBox with: EquipButton, UseButton, DropButton, and CloseButton.

10 Add InventoryButton to WBP_SoulsMobileHUD. The next implementation step binds this button to open WBP_SoulsInventory.

Functional Inventory UI Functional

The Inventory UI is now integrated with the SoulsInventoryComponent. It opens from the mobile HUD, reads real player item stacks, generates visible item rows, filters by tab, and updates the details panel when an item is selected.

• Real-time Population: Automatically fetches items from the player's inventory component upon opening or refreshing.
• Tab Filtering: Functional tabs for All, Weapons, Consumables, and Key Items.
• Item Rows: Uses WBP_SoulsInventoryItemEntry for a clickable row with item icon, name, and quantity.
• Item Selection: Clicking an item entry updates the details panel with the item's name, type, quantity, description, and icon.
• Equipment Integration: Shows currently equipped weapons and quick items.
• Action Button States:
  • Equip: visible for equippable items. It changes to Unequip or Switch when appropriate.
  • Use: visible only for usable items.
  • Drop: visible only for droppable items that are not currently equipped.

Equipment and Action Rules PRO

The inventory action bar is driven by item data and equipment state. Buttons that do not apply to the selected item should be Collapsed, not merely disabled, so the mobile UI stays clean.

Inventory Input Enhanced Input

The inventory should be opened through the same Enhanced Input workflow as the rest of the kit, not through one-off keyboard events. Add or verify IA_Inventory in the player input mapping context, bind it to a keyboard key such as I, and call the same inventory toggle function used by the mobile HUD InventoryButton.

Inventory Item Entry Widget Required

Create the generated row widget as WBP_SoulsInventoryItemEntry in /Game/SoulsMobileKit/Blueprint/Widget/ and set its parent class to SoulsInventoryItemWidget. The C++ class provides the data bridge; the Blueprint widget provides the visible row design.

1 Use this hierarchy for a simple row:

SizeBox
  Border or Button
    HorizontalBox
      ItemIconImage
      ItemNameText
      QuantityText

2 Mark these widgets as variables with exact names: ItemIconImage, ItemNameText, and QuantityText.

3 Set the row height to about 44, avoid fixed width, and let the row fill its parent list horizontally.

4 In WBP_SoulsInventory, set ItemEntryClass to WBP_SoulsInventoryItemEntry. Do not leave it pointing at the native C++ class alone, because the native class has no visual Blueprint layout.

Tabbed List Layout Layout Rule

The four inventory lists should share the same space under the Items heading. Use Collapsed for inactive lists so they do not reserve layout space.

ItemsPanel
  ItemsPanelTitleText
  Overlay
    ItemsList
    WeaponsList
    ConsumablesList
    KeyItemsList

• Default open: ItemsList is Visible; the other lists are Collapsed.
• Weapons tab: only WeaponsList is Visible.
• Consumables tab: only ConsumablesList is Visible.
• Key Items tab: only KeyItemsList is Visible.
• Fill behavior: each list and each generated entry row should fill the Items column width.

What This System Does

The player can now interact with nearby world actors through one shared flow. Pickups, bonfires, and doors use the same interaction base, so new objects can be added without rebuilding input logic.

• Shared Base: use SoulsInteractable for any object the player can activate.
• Player Input: assign Interact Action on the player, then call Try Interact.
• Prompt Text: each object can return its own text through Get Interaction Prompt.
• Manual Loot: pickups can be collected by interact instead of only overlap.
• Bonfire Rest: bonfires can rest/save from the same interact button.
• Door Example: SoulsDoorInteractable gives a simple open/close world object.

Quick Setup: Interact Input

1 Create an input action named IA_Interact.

2 Add it to your player input mapping, for example IMC_SoulsPlayer.

3 Open your player Blueprint and assign IA_Interact to Interact Action.

4 Press the mapped button near a pickup, bonfire, or door. The player will choose the closest valid interactable inside its radius.

Manual Loot Pickup

Use this when you want loot to stay on the ground until the player presses the interact button.

1 Open your pickup Blueprint based on SoulsItemPickup.

2 Disable Pickup On Overlap.

3 Set Interaction Radius to a comfortable value such as 150 or 180.

4 Walk near the pickup and press Interact. The pickup disappears only after the item is added to inventory.

5 For enemy loot, use a pickup class with overlap disabled if you want manual collection after death.

Bonfire Interaction

Bonfires still support quick overlap testing, but the normal Souls-like flow is manual rest.

1 Place your BP_Bonfire in the level.

2 Disable Auto Activate On Overlap for manual rest.

3 Keep Restore Stats On Rest and Save Immediately enabled for the normal checkpoint loop.

4 Approach the bonfire and press Interact. This activates the checkpoint, restores stats, and saves if enabled.

Door or Gate Example

1 Create a Blueprint from SoulsDoorInteractable, for example BP_Door.

2 Add a door mesh as a child of DoorRoot.

3 Leave Closed Relative Transform at the default closed position.

4 Set Open Relative Transform to the open rotation or offset you want.

5 Enable Can Close Again if the same button should close the door after opening.

6 Press Interact near the door to toggle it.

Locked Doors & Gates

Doors can now be configured as locked, requiring a specific SoulsItemDataAsset to open. This is intended as a small world-use foundation for keys, dungeon items, and special items.

1 Create or open a Blueprint based on SoulsDoorInteractable, for example BP_LockedGate.

2 Add your gate or door mesh under DoorRoot, then set Closed Relative Transform and Open Relative Transform.

3 Set bStartsLocked to true.

4 Assign RequiredKeyItem to DA_Item_Key or your own key data asset.

5 Optional but recommended: set RequiredUnlockId to match the key's UnlockId, such as Gate.CourtyardKey.

6 Customize LockedPromptText, UnlockPromptText, and MissingKeyMessage.

7 Listen for OnDoorUnlocked or OnDoorUnlockFailed for sound, VFX, UI feedback, or Blueprint-specific logic.

Manual Validation: Key Door

Use this short checklist after placing BP_Key and BP_LockedGate in the showcase map.

What This System Does

The ASoulsShowcaseRouteGuide is a development-only tool designed to help level designers build the "Perfect Souls Loop". It provides visual lines and points in the editor to represent the standard demo path.

• Visual Path: Draws debug lines and spheres between key gameplay points.
• Logical Points: Standardizes the "Bonfire -> Enemy -> Reward -> Return" flow.
• Quick Validation: Check if all critical showcase actors are linked with one button.
• Blueprint Friendly: Can be customized as BP_ShowcaseRouteGuide.

How to Use

1 Create a Blueprint from SoulsShowcaseRouteGuide, for example BP_ShowcaseRouteGuide.

2 Place it in your Showcase map.

3 Auto-Setup: Click Auto Discover Actors in the details panel to automatically link actors with tags: Bonfire, ShowcaseEnemy, ShowcaseReward, and ReturnPoint.

4 Alternatively, manually assign your actors to the properties: Bonfire Actor, Enemy Encounter Actor, etc.

5 Enable Show Route Debug to see the visual path in the editor viewport.

6 Click Validate Route Setup to check for missing assignments and view the total Route Total Distance in the details panel.

What This System Does

The kit includes a lightweight checkpoint system designed for fast production. Drop a Bonfire actor in the level, let the player activate it, and the project stores the checkpoint transform, souls value, HP percentage, and stamina percentage in a save slot.

• Checkpoint: saves the Bonfire location and optional Checkpoint Id.
• Rest: can restore HP and stamina when activated.
• Save Slot: saves immediately by default, so the player can return to the same checkpoint later.
• Auto Respawn: the player can automatically return to the last Bonfire after death.
• Safe Revive: restores the character mesh from death/ragdoll state and gives a short invulnerability window.

Current Implemented Flow Verified

This is the working first production pass used by the showcase test. It is intentionally simple, but it already covers the full loop needed for a playable Souls-like prototype.

• Bonfire activation: saves the respawn point using Player Respawn Offset, not the exact Bonfire center.
• Player death: stops input, clears sprint/lock-on/combat state, then starts the death sequence.
• Death presentation: can play a death montage, optional ragdoll, and optional respawn widget.
• Respawn: teleports to last checkpoint, restores HP/stamina/souls snapshot, restores mesh pose, then returns control.
• No checkpoint fallback: if no Bonfire was activated, the player returns to the original spawn transform.

Quick Setup: Place a Bonfire

1 Create a Blueprint from SoulsBonfire, for example BP_Bonfire.

2 Add your mesh, flame effect, light, and sound inside the Blueprint.

3 Set Interaction Radius to the distance where the player can rest.

4 Enable Auto Activate On Overlap for instant checkpoint testing, or keep it disabled and call Activate Bonfire from your interact button.

5 Keep Restore Stats On Rest and Save Immediately enabled for the normal Souls-like flow.

6 Adjust Player Respawn Offset so the player revives beside or in front of the Bonfire, not inside the Bonfire mesh.

Production Tip

Keep the first Bonfire version simple: activation, visual feedback, save, and respawn. Add menus, fast travel, level-up, and enemy reset later only after the combat loop feels stable.

No-Button Death Screen

The respawn widget is optional and does not need buttons. A clean first version is just a fullscreen black overlay with centered text. The character system adds it on death and removes it automatically after respawn.

1 Create a Widget Blueprint, for example WBP_Respawn.

2 Add a fullscreen black Image or Border with partial opacity.

3 Add centered text such as YOU DIED.

4 Optional: add a fade-in animation inside the widget.

5 Assign it to Respawn Widget Class on the player Blueprint.

Testing Death and Respawn

Create a Blueprint from SoulsDamageVolume and place it near the Bonfire. This gives you a clean way to test damage, death, and checkpoint respawn without waiting for enemy attacks.

1 Create BP_DamageVolume from SoulsDamageVolume.

2 Scale the DamageBox so the player can walk into it.

3 Set Damage Amount to 25 for normal testing, or 999 to test instant death.

4 Keep Player Only enabled if you do not want enemies to take trap damage.

5 Enable Damage Over Time if the volume should hurt the player repeatedly while standing inside.

What This System Does

Enemies can now award souls when killed. If the player dies while carrying souls, the player drops a recovery pickup, respawns at the checkpoint with zero carried souls, and can recover them by returning to the drop. If the player dies again before recovery, the old pickup is destroyed and those old souls are permanently lost.

• Enemy Reward: set Soul Reward on enemy Blueprints.
• Death Drop: player can spawn a recoverable souls pickup on death.
• Recovery: pickup can be recovered by Interact or by overlap.
• Double Death Loss: only the latest dropped souls marker can be recovered.
• Checkpoint Loop: player respawns at bonfire while dropped souls stay in the world.
• HUD Counter: WBP_SoulsMobileHUD can show the live souls value through SoulsText.

Quick Setup: Enemy Souls Reward

1 Open an enemy Blueprint.

2 In Souls > Enemy > Souls Reward, enable Award Souls On Death.

3 Set Soul Reward to the amount the player receives, for example 25 for a weak enemy.

4 Keep Award Souls For Training Dummy disabled unless the dummy is being used for economy testing.

5 Kill the enemy. The attacking player receives the reward immediately.

Quick Setup: Player Death Recovery

1 Open the player Blueprint.

2 In Souls > Player > Souls Recovery, enable Drop Souls On Death.

3 Leave Souls Recovery Pickup Class empty to use the default recovery pickup, or assign your own visual Blueprint.

4 Keep Recover Dropped Souls On Overlap disabled if you want the player to press Interact.

5 Die while carrying souls. The player drops a recovery pickup and respawns with zero carried souls.

6 Return to the pickup and press Interact to recover the dropped amount.

Souls Recovery Grace Period

To prevent the "Instant Recovery" bug where the player accidentally collects their souls immediately upon death, the system now implements a mandatory spawn grace period.

• Recovery Grace Period: Default 0.75s. Configurable in the souls recovery pickup class.
• Overlap Protection: During the grace period, the pickup ignores all overlap events.
• Living Player Safety: Only living players can recover souls. This prevents the dead body from accidentally consuming the souls before the respawn flow is complete.
• Post-Grace Check: When the timer expires, the pickup automatically checks for overlapping players, ensuring smooth recovery even if the player remains stationary.
• Debug Logs: The system now logs the specific class and location of each spawned marker, such as [Souls] Dropped Souls Recovery Marker! Class: BP_SoulsDroppedSoulsPickup at [Location].

Soul Loss on Double Death

To maintain the challenge of the Souls-like loop, failing to recover your souls before dying again results in the permanent loss of the previous souls.

• The Rule: Only the most recent souls dropped are recoverable.
• Double Death: If the player dies while a souls marker is already in the world, the old marker is destroyed instantly before the new one spawns.
• No Stacking: Souls markers do not stack. The player must choose between safety and the risk of recovering their previous cache.
• Example: die with 10 souls, earn 10 more, then die again before recovery. The first 10 are lost, and the new marker contains only the latest 10.

Bonfire Level Up Lite

Spend your hard-earned souls at any bonfire to permanently increase your character's power. This system provides a clean C++ foundation for RPG progression.

How to Implement UI:

The bonfire now broadcasts OnBonfireLevelUpAvailable when activated. Link your Level Up Widget to this event and use these functions:

• InitializeLevelUpWidget(Actor)
• RefreshLevelUpValues()
• UpgradeHPFromWidget()
• UpgradeStaminaFromWidget()
• UpgradeAttackFromWidget()
• CloseWidget()

UI Widget Setup:

Create a Widget Blueprint WBP_BonfireLevelUp inheriting from SoulsBonfireLevelUpWidget. You MUST name your components exactly as follows for C++ binding:

Quick Setup: HUD Souls Counter

1 Open WBP_SoulsMobileHUD.

2 Add or select the Text Block used for souls display.

3 Name it exactly SoulsText.

4 Compile and save the widget. No extra graph logic is required for the basic counter.

5 Kill an enemy, die with souls, or recover dropped souls. The number should update automatically.

What This System Does

The USoulsInventoryWidget provides a premium C++ bridge to the existing inventory backend. It handles item filtering by tabs, selection details, and provides native hooks for equipping weapons or using consumables.

• Tabbed Navigation: Filter items into Weapons, Consumables, and Key Items.
• Detail Panel: Displays item names, descriptions, icons, and quantities automatically.
• Equipment Slots: Visual feedback for Right Hand, Left Hand, and Quick Item slots.
• Action Hooks: Native C++ support for selected item action states, with gameplay actions ready to extend.
• Blueprint Friendly: Inherit from USoulsInventoryWidget to build your visual design.

1. Chest & Container Logic

The ASoulsContainerInteractable provides a professional base for world containers that grant loot and persist their state.

• Loot Granting: Automatically adds a list of items to the player's inventory upon opening.
• One-Time Use: Configurable persistence ensures chests stay opened across deaths and reloads.
• Interaction: Uses the shared interaction flow for a seamless world experience.
• Persistence ID: Each chest uses a unique ContainerId to track its state in the SoulsSaveGame.

2. Bonfire Storage Box

Enable players to manage their inventory at bonfires by depositing or withdrawing items using the ASoulsStorageBoxInteractable.

• Deposit/Withdraw: Transfer items between player inventory and persistent storage.
• Stack Management: Automatically merges stacks and handles item quantities correctly.
• Persistence: Storage content is saved to a global map in SoulsSaveGame, accessible from any storage box with the same StorageId.
• Blueprint Hooks: Includes OnStorageChanged, OnDepositFailed, and OnWithdrawFailed events for UI updates.

3. Interaction Prompt HUD

Dynamic visual feedback that informs the player when they are within range of an interactable object, supporting both mobile and keyboard inputs.

• Proximity Focus: Automatically detects the nearest interactable and updates the HUD prompt (e.g., "Press E to Rest").
• Contextual Text: Prompts change based on the object state (e.g., "Open Chest" vs "Opened").
• Seamless Integration: Integrated directly into USoulsMobileHUD for consistent performance.
• Mobile Ready: Enables/Disables interaction buttons dynamically based on proximity focus.

1 Create a Widget Blueprint (Parent: SoulsFloatingText) and add a Text Block named DamageText.

2 Implement the Logic Schematic shown below to handle critical hits and animations.

Character Configuration

• Damage Text Class: Assign your WBP_FloatingText in BP_SoulsCharacter or BP_SoulsEnemy.
• Bone Name: Recommended: head or spine_03.
• Optimization: The system automatically pools and destroys these widgets to prevent performance drops.

MOBILE UX

Souls Mobile Move Stick Widget PRO

The USoulsMobileMoveStickWidget is a C++ foundation for creating high-performance virtual joysticks. It handles normalized 2D input vectors, deadzones, and radius clamping natively, ensuring smooth character movement on mobile devices.

• Automatic Cleanup: Actions are automatically finished when their associated montage ends, even if interrupted by other logic.
• Fail-Safe Timeout: If an action somehow fails to report completion, a background fail-safe timer (Montage Length + 0.5s) will automatically clear the busy state.
• Montage Control: Use the bActionSystemPlaysMontage flag on your Data Asset to choose whether the Action System should play the montage itself or just act as a validation/cooldown wrapper.

1 Right Click in Content Browser -> Miscellaneous -> Data Asset.

2 Select SoulsActionDataAsset as the class.

3 Name it (e.g., DA_Action_LightAttack).

4 Configure stamina cost, cooldown, montage, and validation rules.

How Overrides Work

• Priority 1: The system checks the currently equipped weapon's Action Overrides category.
• Priority 2: If the weapon override is empty, it falls back to the character's default action asset.
• Priority 3: If both are empty, the legacy hard-coded combat logic is executed.

System Overview

The system is split into Status Effects and Buffs. Status Effects are buildup-triggered gameplay states such as Poison, Bleed, Burn, Frost, Stun, or Custom effects. Buffs are timed stat modifiers such as Attack Up, Defense Up, Stamina Regen Up, Move Speed Up, or Custom designer-defined effects.

All core logic lives in C++ for stability and performance, while designers tune behavior through Data Assets and Blueprint widgets. The system connects weapons, consumables, HUD feedback, inventory details, and stack behavior into one reusable foundation.

• Status Effects: Track buildup, decay buildup over time, trigger when the threshold is reached, optionally deal damage over time, and optionally stack.
• Buffs: Apply timed gameplay modifiers to Max HP, Max Stamina, Attack Power, Defense, Stamina Regen, Move Speed, or Custom logic.
• Inventory Use: Consumables can heal, apply a buff, cleanse one status effect, or cleanse all negative status effects.
• Weapon On-Hit Status: Weapons can apply status buildup on light and heavy hits through weapon Blueprint defaults.
• HUD Feedback: Active buffs and triggered statuses appear as icons with remaining seconds, optional stack text, and optional radial expiry overlay.
• Inventory Details: Selected items show healing, buffs, cleanses, stack rules, and weapon on-hit status information.
• Professional Stacking: Re-applying an effect can do nothing, refresh duration, extend duration, increase stack count, or increase magnitude depending on each Data Asset.

1 Create a Data Asset of type SoulsStatusEffectDataAsset. Recommended folder: Content/SoulsMobileKit/Data/Effects.

2 Name it clearly, for example DA_Status_Poison, DA_Status_Bleed, DA_Status_Burn, or DA_Status_Frost.

3 Configure identity, buildup, damage, rules, HUD stack display, and debug fields.

1 Create a Data Asset of type SoulsBuffDataAsset. Recommended folder: Content/SoulsMobileKit/Data/Effects.

2 Name it clearly, for example DA_Buff_AttackUp, DA_Buff_StaminaRegen, DA_Buff_DefenseUp, or DA_Buff_MoveSpeed.

3 Add one or more Modifiers. Each modifier has ModifierType, AdditiveValue, and MultiplierValue.

4 Set Duration. Use a positive duration for temporary buffs. Use 0 only for infinite/manual clear behavior.

What This MVP Does

Weapon Abilities are special actions owned by the currently equipped weapon. They allow weapons to feel different in gameplay, not only different in damage numbers.

The weapon points to a SoulsActionDataAsset, the player presses a HUD or input button, and the existing USoulsActionComponent handles stamina, cooldown, alive/grounded checks, busy state, and montage playback rules.

• Designer-facing: create or edit a SoulsActionDataAsset and assign it to a weapon Blueprint.
• Player-facing: press the mobile ability button or the mapped input action to trigger the equipped weapon skill.
• Safe fallback: if the weapon has no ability, the input does nothing safely. With Action System debug enabled, the Output Log can explain why.
• Current example: a sword-style Forward Slash or general Ability Attack using an existing attack montage.

1 Create the action: Create a SoulsActionDataAsset named DA_Action_Sword_ForwardSlash or use the existing DA_Action_Ability.

2 Set action identity: Set Action Id to SwordForwardSlash, Display Name to Forward Slash, and Action Type to Weapon Ability.

3 Set action cost: Set Stamina Cost to 30 and Cooldown to 2.0.

4 Set action rules: Disable Can Be Buffered for the first test. Keep Requires Grounded, Requires Alive, and Requires Enough Stamina enabled.

5 Assign animation: Assign a weapon attack montage to Action Montage. Leave Action System Plays Montage off first unless the ability does not animate during testing.

6 Link the weapon: Open the weapon Blueprint and assign the action asset to its WeaponAbilityAction property.

7 Link the HUD: In WBP_SoulsMobileHUD, add or confirm a button named WeaponAbilityButton. The C++ HUD binding will use it if present.

8 Playtest: Equip the weapon, press the ability button, and confirm animation, stamina cost, cooldown, and safe failure behavior.

No Ability Weapon Safety Test

The system is designed to "fail safely" if a player attempts to use a weapon skill on a weapon that has no WeaponAbilityAction (and no moveset-level ability).

• Safe Return: ASoulsCharacterBase::TryWeaponAbility returns false immediately.
• No Side Effects: No stamina is consumed, no montages are played, and no internal action states are changed.
• Debug Logging: If bDebugActionSystem is enabled on the character, the Output Log will explicitly state: [Souls Action] No weapon ability assigned.

Purpose

The Forward Lunge option makes the first Weapon Ability feel like a real weapon art instead of a normal attack montage. When enabled on a Weapon Ability action, the character moves forward over a short duration while the ability is executing.

This is useful for sword slashes, axe rushes, guard-break attacks, and any short-range special attack that should close a small gap. It should stay optional because not every ability should move the player: buffs, ranged casts, defensive arts, and stationary heavy slams may feel better with lunge disabled.

Forward Lunge Setup

1 Open DA_Action_Sword_ForwardSlash or the current Weapon Ability action.

2 Search for Lunge in the Details panel.

3 Enable bUseForwardLunge.

4 Set ForwardLungeDistance = 250 and ForwardLungeDuration = 0.18.

5 Save the Data Asset, equip the weapon that references it, and press WeaponAbilityButton.

Overview

The weapon ability and moveset system extends combat from generic light/heavy attacks into specialized, weapon-driven behavior. Each weapon can have a unique Weapon Ability and a comprehensive Moveset that defines its mechanical identity.

The system relies on SoulsActionDataAsset for ability logic, WeaponAbilityAction on the weapon blueprint, and SoulsWeaponMovesetDataAsset for organizing actions and montages with a strict resolution priority: Moveset > Weapon Override > Legacy Fallback.

Reference Examples

Merchant Backend

The ASoulsVendorNPC provides a robust C++ backend for creating interactive merchants. It handles item stock, pricing overrides, and secure transactions between the player's inventory and Souls currency.

Create a Blueprint class from SoulsVendorNPC, place it in the level, set its Interaction Prompt to a short label such as Trade, and populate the vendor stock list in the Details panel.

1 In the Content Browser, create a new Blueprint Class and choose SoulsVendorNPC as the parent.

2 Name it BP_SoulsVendor and place it under Content/SoulsMobileKit/Blueprints/Interaction.

3 Add a simple mesh or character visual component, then compile and save.

4 Set Interaction Prompt to Trade and keep Can Interact enabled.

5 Add one or more entries to Stock, assigning item data, quantity, price override, and infinite-stock behavior.

6 Assign VendorWidgetClass to WBP_SoulsVendor and keep bOpenVendorWidgetOnInteract enabled.

7 Place the Blueprint in the level and interact with it to open the shop UI.

Dialog Foundation

The ASoulsDialogNPC provides a lightweight solution for Souls-like NPC interactions. It uses USoulsDialogDataAsset to define dialog lines, speaker names, and portraits, integrated with the global Save System via World Flags.

1 Create a Blueprint inheriting from SoulsDialogNPC.

2 Assign your DialogData asset and DialogWidgetClass (WBP_SoulsDialog).

3 Set a unique PersistentDialogId if you need to track specific NPC state beyond world flags.

4 Set the interaction prompt to a short verb such as Talk.

5 Interact with the NPC in-game to start the dialog flow.

• [ ] Prompt: Does the NPC show Talk only while it is available?
• [ ] Line Flow: Does NextButton advance through each dialog line and finish cleanly?
• [ ] Save Flag: Does the CompletedWorldFlag become saved after finishing the dialog?
• [ ] Non-Repeatable: With bRepeatable disabled, does the NPC hide the prompt and ignore Interact after completion?
• [ ] Save/Load: After saving and restarting play, does the completed non-repeatable NPC remain disabled?
• [ ] Reward Once: If a reward is configured, is it granted only once when bGiveRewardOnce is enabled?

Designer-Friendly Foundation

The ASoulsLadderInteractable lets designers place climbable ladders without hand-positioning every helper point in every level instance. The system can auto-generate climb and mount points from simple settings, while still allowing manual point editing for special layouts.

1 Create or place BP_SoulsLadder in the level.

2 Keep bAutoConfigurePoints enabled for normal ladders.

3 Set LadderHeight to match the climbable height.

4 Set MountForwardOffset so the player exits safely away from the ladder face.

5 Use bShowLadderPointDebugInEditor to show or hide helper points while designing.

Boss System

Bosses feature specialized attack patterns and health-based transitions. Enabling bIsBoss on SoulsEnemyBase activates the boss HUD range flow, while Boss Phases defines how the encounter changes as health drops.

Boss HP HUD Integration

Professional mobile-first Boss Health display with support for multiple phases and proximity-based visibility. The HUD automatically syncs with the boss's status component and handles range-based detection.

Setup Instructions:

1. Create a Widget Blueprint inheriting from SoulsBossHealthWidget (e.g., WBP_SoulsBossHealth).
2. Assign this class to the Boss Health Widget Class property in your main WBP_SoulsMobileHUD.
3. In your Boss Enemy Blueprint, enable bIsBoss and bShowBossHealthHUD.
4. Configure Boss Display Name and Boss HUD Range (distance at which the HUD appears).

Required Component Bindings:

Ensure your WBP_SoulsBossHealth contains these components with exact names for native C++ binding:

Phase Icon Setup:

To enable phase icons, create a separate Widget Blueprint inheriting from SoulsBossPhaseIconWidget (e.g., WBP_SoulsBossPhaseIcon). Assign it to Boss Phase Icon Widget Class in your health widget settings.

• Required Child: An Image component named IconImage with Is Variable enabled.
• Custom Icon Source: Assign Phase Icon inside each entry of the boss's Boss Phases array. The HUD passes that texture into the icon widget automatically.
• Behavior: Icons represent configured boss stages. Completed stages use the inactive tint, while current and remaining stages use the active tint.
• Fallback: If no icon widget is assigned, the system skips rendering icons safely without errors.

Advanced Multi-Phase Setup

Create complex boss encounters with unlimited phases using the data-driven Boss Phases system. Each phase can have its own health threshold, cinematic transition, and unique ability set.

Configuration:

• bUseBossPhases: Enable this to activate multi-phase logic on the boss.
• Boss Phases Array: Add entries for each phase of the fight.
  • Phase Display Name: Custom label shown in the HUD (e.g., "Enraged" or "Final Form").
  • Phase Icon: Optional custom texture for the HUD phase indicator.
  • Health Threshold: Health percentage (0.0 to 1.0) required to enter this phase.
  • AI Abilities: The set of abilities the boss will prioritize in this phase.
  • Transitions: Configure optional Montage, Sound, and VFX to play when the phase starts. The boss can stop movement, pause AI decisions, and resume combat after the transition completes.
  • Behavioral Flags:
    • Stop Movement: Immediately halts all movement and AI pathing when the transition starts.
    • Can Take Damage During Transition: Controls if the player can damage the boss while the transformation is playing.
    • Allow Rotation During Transition: If enabled, the boss can continue facing the player during the transition. Keep it disabled for rooted cinematic transformations.
    • Prevent AI Decisions: Pauses all combat and ability logic until the transition completes.

HUD Synchronization:

The Boss HP HUD automatically reads the Boss Phases array to determine the total number of phase icons and displays the current Phase Display Name. If no name is provided, it defaults to "Phase X". This ensures a consistent professional look regardless of encounter complexity.

Recommended Three-Stage Setup:

Manual Test:

1. Place a boss with bIsBoss, bShowBossHealthHUD, and bUseBossPhases enabled.
2. Add two or more entries to Boss Phases and assign different display names.
3. Assign a transition montage to a later entry and keep movement/AI lockout enabled.
4. Enter the HUD range, damage the boss below the next threshold, and confirm the boss stops, plays the transition, then resumes combat.
5. Confirm the Boss HP bar, health text, phase label, and phase icons update during the fight.

3. Mobile-Safe UI Flow

Critical mobile interfaces are designed to open, close, and return to gameplay without trapping touch input. Inventory and Bonfire Level Up are validated as the primary mobile flow; other optional screens can follow the same pattern if your project expands them.

• Touch Priority: HUD buttons, inventory actions, and bonfire controls remain usable with mobile-style tapping.
• Safe Input Return: Closing a menu restores movement, camera look, attack, block, dodge, interact, and inventory controls.
• Reusable Pattern: Vendor, storage, and save-slot screens can reuse the same mobile-safe open/close rules when customized for a specific game.

Native C++ Title Screen Flow

The SoulsMainMenuWidget class implements a "Tap to Start" title screen behavior common in mobile AAA titles. It automatically detects existing save data to switch between "Tap to Start" and "Continue" modes, and handles the deferred loading of the saved world state.

1 Create a Widget Blueprint (e.g., WBP_MainMenu).

2 Set the Parent Class to SoulsMainMenuWidget.

3 In Class Defaults, configure MapToOpen (your New Game fallback map) and SettingsWidgetClass.

4 Place a large Button named StartButton. To make the entire screen touch-sensitive, set the button's background alpha to 0 and stretch it to cover the viewport.

Core Features

• Live Preview: Layout scale and Master Volume apply instantly as you slide.
• HUD Integration: The LayoutScaleSlider directly scales the entire mobile HUD in real-time.
• Persistence: Settings are saved to the SoulsSaveGame system and persist across restarts.
• Save Management: Built-in confirmation flow for resetting or deleting save data.

1 Create WBP_MobileSettings inheriting from SoulsSettingsWidget.

2 Add sliders and combo boxes in the Designer.

3 Critical: Ensure your widget names match the required bindings below.

4 Configure the DeleteSaveConfirmPanel as a hidden child widget for safety.

• Game remains paused on close: The system now forces unpause and restores GameOnly input mode when the settings menu is closed. Ensure you call CloseSettings() in C++ or Blueprint to trigger this restoration.
• Graphics Quality resets: The system uses ApplyMobileSettings to persist quality levels to both the save file and the engine runtime (via GameUserSettings). If settings reset, verify the GraphicsQualityComboBox index matches the preset level (0=Low, 3=Ultra).
• Delete Save fails: The confirmation panel must be named DeleteSaveConfirmPanel in your WBP. Deletion uses ResetProjectSaveData which wipes both disk and memory, returning all settings to defaults.
• Returning to Menu: Delete Save can optionally return the player to a configured level such as MainMenu. Set LevelToOpenAfterDeleteSave in the settings widget defaults to enable this transition.

Native Loading Management

The SoulsLoadingScreenWidget provides a smooth transition layer that stays visible during level travel and only hides once the destination world is fully ready and save data (if any) is restored.

1 Create a Widget Blueprint (e.g., WBP_LoadingScreen).

2 Set the Parent Class to SoulsLoadingScreenWidget.

3 In your GameInstance Blueprint (e.g., BP_SoulsGameInstance), assign your widget to the LoadingScreenWidgetClass property.

4 Tweak LoadingScreenHideDelay (default 0.2s) to ensure the world is settled before the screen fades.