Overview

BlueLine is a professional productivity suite for Unreal Engine 5.7, designed to solve the three biggest frictions in professional Unreal development: Messy Blueprint Graphs, Invisible Data, and Clunky Level Editor Workflows.

Using BlueLine

Welcome to a cleaner workflow. This section covers the essential first steps for new users to get the most out of BlueLine's intelligence features.

1. Setting Up Colored Tags

BlueLine's visual clarity depends on your Theme Data. By mapping Gameplay Tags to colors, you turn generic grey wires into a color-coded map of your logic.

2. Mastering Auto-Tagging (Shift+T)

Don't waste time creating comment boxes. Let BlueLine's semantic analyzer do it for you.

Installation & Build

Because BlueLine modifies the Editor Source (GraphPins, Property Editors, and Level Viewport), it must be compiled with your project.

1. Copy the BlueLine folder into your project's /Plugins/ directory.
2. Right-click your .uproject file and strictly select Generate Visual Studio Project Files.
3. Open `YourProject.sln`.
4. Build Solution (Ctrl+Shift+B).
5. Launch Unreal Engine. Enable the plugin in Edit > Plugins.

Smart Pivot Snapping

BlueLine's pivot tools understand the visual geometry of your meshes, not just bounding boxes.

Intelligent Bounds Calculation

When calculating the center or bottom of an actor, BlueLine ignores non-visual components like:

• Billboard Components (sprite icons)
• Collision volumes
• Hidden editor-only components

This ensures the pivot snaps to the visible mesh, not invisible bounding artifacts.

Container vs. Mesh Handling

Material-Based Selection

The Select Scope feature allows rapid selection of visually related actors in your level.

How It Works

1. Select an actor with a mesh (e.g., a wooden crate).
2. Open the Pie Menu (Alt+S) and hover over Select Scope.
3. BlueLine scans the entire level once and caches all actors sharing any material with your selection.
4. Mouse wheel adjusts the radius (50 - 50,000 units).
5. Click to select all matching actors within the radius sphere.

Manhattan Routing (Shift+R)

Blueprint spaghetti is often caused by long, diagonal splines that cross over unrelated nodes. Manhattan Routing enforces 90-degree discipline across your selection.

Intelligent Backwards Flow

When routing connections to nodes placed *behind* the source (Backwards Flow), BlueLine automatically calculates a Safe Perimeter to route the wire around the node body, preventing the wire from passing through the node's visual area.

Key Features

• 1. Multi-Point Alignment: Automatically calculates the mid-points for L and Z-style bends.
• 2. Knot Centering: Ensures reroute nodes are perfectly centered between their connected pins.
• 3. Proximity Awareness: Will not trigger if pins are too close together, preventing "knot clusters" in tight spaces.

Graph Bookmarks Alt+1-9

Save and instantly navigate to important nodes in your Blueprint graphs. Bookmarks persist per graph across editor sessions, stored in Saved/BlueLineBookmarks.json.

How It Works

1. 1 Select a node in any Blueprint graph.
2. 2 Press Alt+1-9 to save the bookmark (e.g., Alt+5 saves to slot 5).
3. 3 Press 1-9 anytime to jump directly to that node.

Node Snippets Shift+S / Shift+I

Save selected nodes as reusable templates that can be quickly inserted into any graph. Perfect for commonly used logic patterns, function templates, or node setups.

Creating a Snippet

1. 1 Select nodes in any Blueprint graph (can include events, functions, variables).
2. 2 Press Shift+S to open the snippet creation dialog.
3. 3 Enter a name and click OK. The snippet is saved to Saved/BlueLineSnippets.json.

Inserting a Snippet

1. 1 Press Shift+I in any graph to insert the most recently used snippet.
2. 2 Nodes are recreated with connections preserved between them.
3. 3 The new nodes are automatically selected for easy repositioning.

Clean Graph (Shift+C)

For large, tangled logic webs, the Genetic Algorithm finds the global optimum for node placement and wire routing.

The Evolutionary Process

Unlike standard formatters that use fixed rules, BlueLine's Genetic Algorithm (GA) performs a simulation:

• 1. Population: It spawns 50 randomized "Genomes" of your selected nodes.
• 2. Scoring: Each genome is penalized for wire crossings, backward flow, and excessive whitespace.
• 3. Selection: The fittest layouts are kept; the weakest are discarded.
• 4. Mutation: Winners are "bred" with small positional mutations to find the local maxima of readability.

Semantic Auto-Tag (Shift+T)

BlueLine uses Semantic Heuristics to understand what your code does, automatically grouping it into themed Comment Boxes.

Heuristic Intelligence

The FBlueLineSmartTagAnalyzer looks for patterns across the graph:

• Naming: Matches keywords in function names (e.g., "Projectile" → Combat, "Sound" → Audio).
• Connectivity: Groups nodes that are physically linked, even if they share no common keywords.
• Theme Sync: Uses the colors defined in your BlueLineThemeData asset to style the resulting comment boxes.

Smart Tags (Details Panel)

BlueLine hijacks the Details Panel for GameplayTags to inject visual context. It replaces the standard textual row with a composite widget.

Colored Pins (Graph Editor)

Using the custom FBlueLineGraphPinFactory, the plugin also injects styling into the Blueprint Graph itself.

Pin Context Menu

For fine-grained control, BlueLine extends the standard Blueprint pin context menu with localized actions.

Intelligence (IQ) Check

BlueLine won't blindly insert knots if it would make the graph worse. Before straightening, the engine performs a sector scan:

• Collision Detection: If a new Manhattan path would pass directly through an existing node, the action is cancelled.
• Overlap Prevention: If the horizontal distance is less than 64 units, it keeps the spline to avoid a "knot on top of pin" visual glitch.
• Pathfinding: It searches for the "cleanest" side (top vs bottom) to route around obstacles.

Team Setup

BlueLine uses a DataAsset to sync colors across the team. This ensures that if the Lead Designer marks "Status.Dead" as Black, every other developer sees Black instantly.

Step 1: Create the Asset

1. In the Content Browser, right-click and select Miscellaneous > Data Asset.
2. Search for BlueLineThemeData.
3. Crucial: Name the file DA_BlueLineDefault.
4. Place it anywhere in your Content folder (The plugin uses Asset Registry search to find it).

Step 2: Configure Rules

Open the asset and add entries to the Tag Styles array.

Result: Status, Status.Buff, and Status.Buff.Heal will all turn Green automatically.

Runtime Debugging

BlueLine exposes a static library to draw colored debug text in the game world, using the same colors defined in your editor Data Asset.

C++ Usage

#include "Debug/BlueLineDebugLib.h"

void AMyCharacter::Tick(float DeltaTime)
{
    // Draw "Status.Frozen" in Cyan (if defined in DataAsset) above the character
    UBlueLineDebugLib::DrawBlueLineDebugTag(
        this, 
        CurrentStateTag, 
        GetActorLocation() + FVector(0,0,100)
    );
}

Blueprint Usage

Search for the node "Draw BlueLine Debug Tag".

Extract to Subsystem Shift+B

Refactor complex Blueprint graphs by extracting selected nodes into dedicated Blueprint Subsystems. This feature automates the creation of GameInstance, World, or LocalPlayer managers, promoting cleaner architecture and better separation of concerns.

How It Works

Subsystem Types

Visual Example

Export to Text Shift+E

Transform visual Blueprint graphs into human-readable text for debugging, documentation, code reviews, and AI-assisted analysis. The exporter flattens nested logic into an easy-to-follow tree structure.

How It Works

1. 1 Open any Blueprint graph in the editor.
2. 2 Press Shift+E or right-click → "Export to Text" from the BlueLine Graph menu.
3. 3 Choose save location in the file dialog (defaults to [Project]/BlueprintExports/).
4. 4 Open the .txt file in any text editor or paste into your AI tool of choice.

Example Output

=== Blueprint Export: BP_Player ===
Export Type: Full Graph
Total Nodes: 42

Event BeginPlay
└─ then →
  Set Max Health (MaxHealth = 100.0)
  └─ then →
    Set Current Health (CurrentHealth = MaxHealth)
    └─ then →
      Initialize UI (Widget = Create Widget, Class = WBP_HUD)

Event TakeDamage
  Take Damage (Damage = 10.0, DamageType = DamageType_Fire)
  └─ then →
    Apply Damage (Target = Self, BaseDamage = Damage)
    └─ then →
      Branch (Condition = CurrentHealth <= 0)
      └─ true →
        Play Death Animation (Animation = Death_Fire)
        └─ then →
          Destroy Actor (Target = Self)
      └─ false →
        Update Health Bar (Percent = CurrentHealth / MaxHealth)

Event OnHeal
  Heal (Amount = Clamp (Value = Float + Float, Min = 0, Max = MaxHealth - CurrentHealth))
  └─ then →
    Set Current Health (CurrentHealth = CurrentHealth + Amount)

Features

Use Cases

• ✓ Debugging: See full logic flow without clicking through dozens of nodes
• ✓ Code Reviews: Share logic via text instead of screenshots in PRs
• ✓ Documentation: Generate human-readable docs from Blueprints automatically
• ✓ AI Assistance: "Optimize this logic", "Rewrite in C++", "Find bugs"
• ✓ Understanding: Quickly grasp complex Blueprints written by others

Blueprint Subsystems Runtime Module

The BlueLineCore module provides Blueprint-friendly base classes for creating Unreal Engine Subsystems. Create GameInstance, World, and LocalPlayer managers directly in Blueprint without writing C++.

Available Base Classes

Creating a Subsystem

Accessing Subsystems

// Get your custom subsystem from any Blueprint
UGameInstanceSubsystem* Subsystem = GetGameInstanceSubsystem(BP_SaveManager);

// Call custom functions you've defined
Subsystem->SaveGame();
Subsystem->LoadGame();
Subsystem->DeleteSaveSlot(SlotName);