BP2AI - Documentation Showcase

Ability activation system with

47 nodes, 12 functions, and 4 levels of nesting.

You can copy the raw markdown Output already in Confluence Markdown or other Markdown supportive texteditors to get basic readable formatting of the logic flow 

Ability System Documentation

AI Prompt

Analyze this BP2AI trace and generate CONCISE technical documentation for developers. Focus on practical implementation, not theory.

Requirements:

  • Keep total length under 800 words
  • Write for busy developers who need quick answers
  • Focus on "what it does" and "how to use it"
  • Include only essential information

Structure (in this order):

  1. Quick Overview (2-3 sentences): What this system does and why you'd use it
  2. Key Functions (table format): Function name, inputs, outputs, purpose (1 line each)
  3. Critical Setup Requirements: What variables/data you must have
  4. Usage Pattern (1 simple example): How to trigger the system

Avoid:

  • Long explanations of obvious concepts
  • Theoretical architecture discussions
  • Multiple examples
  • Future enhancement speculation
  • Performance optimization advice
  • Detailed error handling sections

Write like a senior developer explaining to another developer in 5 minutes. Format this as Confluence markup with dark theme styling using simple panels (bgColor=#333333), basic headings, tables, code blocks, and note callouts - keep colors minimal and text clean

Ability System Blueprint Trace

**Trace Start: ActivatePlayerAbility
Custom Event** (CustomEvent)

```blueprint
* Event ActivatePlayerAbility Args: (AbilityID:int, PlayerRef :BP_FirstPersonCharacter, TargetLocation:Vector)
    * Call Function: [ValidateAbilityActivation](#bp-showcase-validateabilityactivation)(AbilityID=ActivatePlayerAbility.AbilityID, Player=ActivatePlayerAbility.PlayerRef )
        * If (([ValidateAbilityActivation](#bp-showcase-validateabilityactivation)(AbilityID=ActivatePlayerAbility.AbilityID, Player=ActivatePlayerAbility.PlayerRef )).isValid )
            |-- true:
            |   * Collapsed Graph: [ProcessAbilityEffects  Collapsed Graph](#bp-showcase-processabilityeffects-collapsed-graph)(AbilityID=ActivatePlayerAbility.AbilityID, TargetLocation=ActivatePlayerAbility.TargetLocation)
            |       * Call Custom Event: [NotifyGameSystems ](#bp-showcase-notifygamesystems)()
            |           * [Path ends after call to custom event "NotifyGameSystems "]
            L-- false:
                * PrintString((InString=ability cant be used))
                    * [Path ends]
```
---
## Referenced Graphs
### Functions
#### `BP_Showcase.CalculateAbilityDamage` 

**Inputs:**
* `AbilityID ` (int)

**Execution Flow:**

```blueprint
* Event CalculateAbilityDamage
    * If (Map_Find(Key=ValueFrom(CalculateAbilityDamage.AbilityID ), TargetMap=AbilityDefinitions))
        |-- true:
        |   * Set BaseDamage:double = ((Map_Find(Key=ValueFrom(CalculateAbilityDamage.AbilityID ), TargetMap=AbilityDefinitions)).Value).BaseDamage
        |       * Set FinalDamage:double = (((Map_Find(Key=ValueFrom(CalculateAbilityDamage.AbilityID ), TargetMap=AbilityDefinitions)).Value).BaseDamage * 1.25)
        |           * Return(FinalDamage=(((Map_Find(Key=ValueFrom(CalculateAbilityDamage.AbilityID ), TargetMap=AbilityDefinitions)).Value).BaseDamage * 1.25))
        L-- false:
            * PrintString((InString=Unknown ability, using default damage))
                * Return(FinalDamage=10)
```
**Outputs:**
* `FinalDamage` (double) = (((`Map_Find`(`Key`=ValueFrom(`CalculateAbilityDamage`.`AbilityID `), `TargetMap`=`AbilityDefinitions`)).`Value`).`BaseDamage` * 1.25)

---
#### `BP_Showcase.CheckAbilityCooldown` 

**Inputs:**
* `AbilityID ` (int)
* `Player` (BP_FirstPersonCharacter)

**Execution Flow:**

```blueprint
* Event CheckAbilityCooldown
    * Call Function: [GetAbilityLastUsedTime](#bp-showcase-getabilitylastusedtime)(AbilityID=ValueFrom(CheckAbilityCooldown.AbilityID ), Player=ValueFrom(CheckAbilityCooldown.Player))
        * Macro: [Get Ability Cooldown Duration](#bp-showcase-get-ability-cooldown-duration)(AbilityID=ValueFrom(CheckAbilityCooldown.AbilityID ))
            * If (((GetGameTimeInSeconds() - ([GetAbilityLastUsedTime](#bp-showcase-getabilitylastusedtime)(AbilityID=ValueFrom(CheckAbilityCooldown.AbilityID ), Player=ValueFrom(CheckAbilityCooldown.Player))).TimeStamp) >= GetAbilityCooldownDuration.Duration  (Macro Inputs: AbilityID=ValueFrom(CheckAbilityCooldown.AbilityID ))))
                |-- true:
                |   * Return(isReady=true)
                L-- false:
                    * Return(isReady=false)
```
**Outputs:**
* `isReady ` (bool) = true

---
#### `BP_Showcase.CheckAbilityRequirements` 

**Inputs:**
* `AbilityID ` (int)
* `Player` (BP_FirstPersonCharacter)

**Execution Flow:**

```blueprint
* Event CheckAbilityRequirements
    * Macro: [Get Ability Mana Cost](#bp-showcase-get-ability-mana-cost)(AbilityID=ValueFrom(CheckAbilityRequirements.AbilityID ))
        * If ((CurrentMana >= GetAbilityManaCost.ManaCost  (Macro Inputs: AbilityID=ValueFrom(CheckAbilityRequirements.AbilityID ))))
            |-- true:
            |   * Return(MeetsRequirements=true)
            L-- false:
                * Return(MeetsRequirements=false)
```
**Outputs:**
* `MeetsRequirements ` (bool) = true

---
#### `BP_Showcase.GetAbilityLastUsedTime` 

**Inputs:**
* `AbilityID ` (int)
* `Player` (BP_FirstPersonCharacter)

**Execution Flow:**

```blueprint
* Event GetAbilityLastUsedTime
    * If (Map_Find(Key=ValueFrom(GetAbilityLastUsedTime.AbilityID ), TargetMap=AbilityCooldownTimestamps))
        |-- true:
        |   * Return(TimeStamp=(Map_Find(Key=ValueFrom(GetAbilityLastUsedTime.AbilityID ), TargetMap=AbilityCooldownTimestamps)).Value)
        L-- false:
            * Return(TimeStamp=0)
```
**Outputs:**
* `TimeStamp` (double) = (`Map_Find`(`Key`=ValueFrom(`GetAbilityLastUsedTime`.`AbilityID `), `TargetMap`=`AbilityCooldownTimestamps`)).`Value`

---
#### `BP_Showcase.ValidateAbilityActivation` 

**Inputs:**
* `AbilityID ` (int)
* `Player` (BP_FirstPersonCharacter)

**Execution Flow:**

```blueprint
* Event ValidateAbilityActivation
    * Call Function: [CheckAbilityCooldown](#bp-showcase-checkabilitycooldown)(AbilityID=ValueFrom(ValidateAbilityActivation.AbilityID ), Player=ValueFrom(ValidateAbilityActivation.Player))
        * If (([CheckAbilityCooldown](#bp-showcase-checkabilitycooldown)(AbilityID=ValueFrom(ValidateAbilityActivation.AbilityID ), Player=ValueFrom(ValidateAbilityActivation.Player))).isReady )
            |-- true:
            |   * Call Function: [CheckAbilityRequirements](#bp-showcase-checkabilityrequirements)(AbilityID=ValueFrom(ValidateAbilityActivation.AbilityID ), Player=ValueFrom(ValidateAbilityActivation.Player))
            |       * Return(isValid=([CheckAbilityRequirements](#bp-showcase-checkabilityrequirements)(AbilityID=ValueFrom(ValidateAbilityActivation.AbilityID ), Player=ValueFrom(ValidateAbilityActivation.Player))).MeetsRequirements )
            L-- false:
                * Return(isValid=false)
```
**Outputs:**
* `isValid ` (bool) = ([`CheckAbilityRequirements`](#bp-showcase-checkabilityrequirements)(`AbilityID`=ValueFrom(`ValidateAbilityActivation`.`AbilityID `), `Player`=ValueFrom(`ValidateAbilityActivation`.`Player`))).`MeetsRequirements `

---
### Callable Custom Events
#### `BP_Showcase.NotifyGameSystems ` 

**Inputs:**
* `OutputDelegate` (delegate)

**Execution Flow:**

```blueprint
* Event NotifyGameSystems 
    * Call Custom Event: [UpdatePlayerUi](#bp-showcase-updateplayerui)()
        * Call Custom Event: [PlayAbilitySound](#bp-showcase-playabilitysound)()
            * PrintString((InString=BroadcasttoOtherSystems))
                * [Path ends]
```
**Outputs:**
* `OutputDelegate` (delegate) = `NotifyGameSystems `.`OutputDelegate`

---
#### `BP_Showcase.PlayAbilitySound` 

**Inputs:**
* `OutputDelegate` (delegate)

**Execution Flow:**

```blueprint
* Event PlayAbilitySound
    * PrintString((InString=(DA_AbilityOne.WeaponName  + Conv_DoubleToString(InDouble=(DA_AbilityOne.WeaponData ).CooldownDuration))))
        * [Path ends]
```
**Outputs:**
* `OutputDelegate` (delegate) = `PlayAbilitySound`.`OutputDelegate`

---
#### `BP_Showcase.UpdatePlayerUi` 

**Inputs:**
* `OutputDelegate` (delegate)

**Execution Flow:**

```blueprint
* Event UpdatePlayerUi
    * PrintString((InString=PlayerUI to be declared))
        * [Path ends]
```
**Outputs:**
* `OutputDelegate` (delegate) = `UpdatePlayerUi`.`OutputDelegate`

---
### Collapsed Graphs
#### `BP_Showcase.ProcessAbilityEffects  Collapsed Graph` 

**Inputs:**
* `AbilityID` (int)
* `TargetLocation` (Vector)

**Execution Flow:**

```blueprint
* Tunnel (Inputs)
    * Call Function: [CalculateAbilityDamage](#bp-showcase-calculateabilitydamage)(AbilityID=ValueFrom(Tunnel.AbilityID))
        * Set Damage:double = ([CalculateAbilityDamage](#bp-showcase-calculateabilitydamage)(AbilityID=ValueFrom(Tunnel.AbilityID))).FinalDamage
            * Niagara:NiagaraFunctionLibrary.SpawnSystemAtLocation((bAutoActivate=true, bAutoDestroy=true, bPreCullCheck=true, Location=ValueFrom(Tunnel.TargetLocation), PoolingMethod=Niagara:ENCPoolMethod::[Default Value], Rotation=Rotator(P=0, Y=0, R=0), Scale=Vector(X=1, Y=1, Z=1), SystemTemplate=DirectionalBurst))
                * PrintString((InString=ProcessAbilityEffects))
                    * Tunnel (Outputs)
```
**Outputs:**
*(No distinct data outputs)*

---
### Executable Macros
#### `BP_Showcase.Get Ability Cooldown Duration` 

**Inputs:**
* `AbilityID` (int)

**Execution Flow:**

```blueprint
* Tunnel (Inputs)
    * ExecIn:
        * If (Map_Find(Key=ValueFrom(Tunnel.AbilityID), TargetMap=AbilityDefinitions))
            |-- true:
            |   * Tunnel (Outputs)
            L-- false:
                * PrintString((InString=No Ability Found))
                    * [Path ends]
```
**Outputs:**
* `Duration ` (double) = ((`Map_Find`(`Key`=ValueFrom(Tunnel.`AbilityID`), `TargetMap`=`AbilityDefinitions`)).`Value`).`CooldownDuration`

---
#### `BP_Showcase.Get Ability Mana Cost` 

**Inputs:**
* `AbilityID` (int)

**Execution Flow:**

```blueprint
* Tunnel (Inputs)
    * ExecIn:
        * If (Map_Find(Key=ValueFrom(Tunnel.AbilityID), TargetMap=AbilityDefinitions))
            |-- true:
            |   * Tunnel (Outputs)
            L-- false:
                * PrintString((InString=Ability Not found))
                    * [Path ends]
```
**Outputs:**
* `ManaCost ` (double) = ((`Map_Find`(`Key`=ValueFrom(Tunnel.`AbilityID`), `TargetMap`=`AbilityDefinitions`)).`Value`).`ManaCost`

AI Documentation Comparison

Criteria Claude Gemini ChatGPT Winner
Prompt Adherence 10/10 8/10 10/10 Claude/ChatGPT
Length Control 10/10 9/10 10/10 Claude/ChatGPT
Professional Formatting 10/10 7/10 9/10 Claude
Function Completeness 7/10 6/10 10/10 ChatGPT
Practical Value 9/10 8/10 9/10 Claude/ChatGPT
Trace Accuracy 9/10 9/10 9/10 Tie
Developer Readability 10/10 7/10 9/10 Claude
Setup Clarity 9/10 8/10 8/10 Claude

Flow Inspector

 

🚀 Get Started

Ready to unlock AI analysis for your Blueprint workflows?

Join the beta testing program and experience professional Blueprint-to-AI translation.

 

Add comment

Comments

There are no comments yet.

Videos and Images ©Epic Games / JSFILMS / tharlevfx / Peyton Varney