Fixing Blueprint Friction

Start with the hello world, a Pong ball and paddle in 32 nodes, then a whole game, an asteroid shooter: both playing on their converted code, every node lighting up as it runs. Then the real thing: a Blueprint someone pasted online, badly written the way most are, turned into code, traced node by node to the use case and requirement it serves, and drawn as a 3D city. Each friction named in the design discussion The Blueprint Paradox is measured on it.

Three ideas, each shown below: closed loop requirements (sheets 4 and 5), human ergonomics (sheets 2 and 3) and observational understanding (sheet 0's replays here, values and valves on the battles of a game in production).

SampleLock-On System by hitted EngineUE 5.0, read by the 5.7.1 converter Pastes4 texts, 162 nodes Sourceblueprintue.com (the author keeps the rights) Tested bytools, not yet people (IR-12)
START HERE

Hello world: Pong, before the Lock-On

Two pastes from blueprintue.com, Pong - BP_Ball (23 nodes) and Pong - BP_Paddle (9 nodes), UE 4.18, by anonymous: a ball that is served in a random direction, moves every frame, turns off a paddle (its X) and off a wall (its Y), and is served again from a goal; and a paddle the player moves with one axis. Converted to 13 statements in 5 graphs, traced to 6 use cases and 10 requirements: every node, every path (12 of 12) and every question (8 of 8) accounted for; 13 of 13 effects hold on the code and 13 plants flip.

The loop: LOOP OPEN: every hole of ours is closed; 6 owner hole(s), from 3 question(s) only the owner can answer, keep it open

//@graph 1:1 BP_Ball.ReceiveTick
{
    K2_AddActorWorldOffset(Velocity * KismetMathLibrary.Multiply_FloatFloat(DeltaSeconds, Speed), true, false, out _);
}
//@graph 10:1 BP_Ball.ReceiveBeginPlay
{
    var RandomUnitVectorInConeInDegrees_result_2 = KismetMathLibrary.RandomUnitVectorInConeInDegrees(new Vector { X = -1, Y = 0, Z = 0 }, 30);
    Velocity = new Vector { X = RandomUnitVectorInConeInDegrees_result_2.X, Y = RandomUnitVectorInConeInDegrees_result_2.Y, Z = 0 };
}
//@graph 82:1 BP_Ball.BndEvt__Sphere_K2Node_ComponentBoundEvent_0_ComponentBeginOverlapSignature__DelegateSignature
{
    if (OtherActor is BP_Paddle AsBP_Paddle_1) {
        Velocity = new Vector { X = KismetMathLibrary.Multiply_FloatFloat(Velocity.X, -1), Y = Velocity.Y, Z = Velocity.Z };
    }
    if (OtherActor is BP_Wall AsBP_Wall_3) {
        Velocity = new Vector { X = Velocity.X, Y = KismetMathLibrary.Multiply_FloatFloat(Velocity.Y, -1), Z = Velocity.Z };
    }
    if (OtherActor is BP_Goal AsBP_Goal_5) {
        K2_SetActorLocation(new Vector { X = 0, Y = 0, Z = 0 }, false, false, out _);
        var RandomUnitVectorInConeInDegrees_result_8 = KismetMathLibrary.RandomUnitVectorInConeInDegrees(new Vector { X = -1, Y = 0, Z = 0 }, 30);
        Velocity = new Vector { X = RandomUnitVectorInConeInDegrees_result_8.X, Y = RandomUnitVectorInConeInDegrees_result_8.Y, Z = 0 };
    }
}
//@graph 1:1 BP_Paddle.ReceiveTick
{
    K2_AddActorWorldOffset(Velocity * KismetMathLibrary.Multiply_FloatFloat(DeltaSeconds, Speed), true, false, out _);
}
//@graph 11:1 BP_Paddle.K2Node_InputAxisEvent_0
{
    Velocity = new Vector { X = 0, Y = -1, Z = 0 } * AxisValue;
}

Only the author can answer

  • IR-PG-1 A ball that reaches a goal scores a point for the player at the other end, and the score is shown
  • IR-PG-2 The ball's Speed and the paddle's Speed are each set before play, to values the author names
  • IR-PG-3 Which end a serve goes toward, and how wide it may spread, are named design values; today every serve, the first and each after a goal, goes within 30 degrees of -X, toward the same end

What the hello world found in the converter, each fixed, with the class of the fault, and held by a test: a split struct pin read as its default (the serve printed Velocity = (0, 0, 0) where Random Unit Vector was wired); pin ids that repeat across a duplicated node (the paddle was made from the ball), so a pin is found by its node too; two Blueprints' members of one name merged (the paddle's Velocity counted as the ball's); and two names it could not read, the paddle's owner and its axis event's title.

As the Blueprint editor draws them, the reference: each node where its author put it, titles in the engine's own formats, the editor's colours. The box sizes and the grid are this page's.

Pong - BP_Ball as the Blueprint editor draws itPong - BP_Paddle as the Blueprint editor draws it

The same two pastes as a city: point at anything to name it, click it for what it is, and Unreal 2D shows the selected graph's paste as above. Open it full screen.

THEN PLAY

A whole game: an asteroid shooter, running on its converted Blueprint

siljaZ's asteroid shooter (UE 5.0), posted to blueprintue.com a graph at a time: 16 of its pastes, 232 nodes. The ship circles the middle of the screen on one axis and fires into it; asteroids and enemy ships fly out of the middle at it; a hit costs a life and the last one sends the game back to its title. Converted to 83 statements in 20 graphs and traced to 12 use cases: 24 requirements READ from the nodes, every node, every path (53 covered, 11 excluded with the reason) and every question (34 of 34) accounted for; 65 of 65 effects hold on the code and 65 plants flip.

3 / 2games started from the title / ended by the last life, in 180 s with the computer at the controls
93 of 99enemy ships shot down: the paste's own HitboxEnemy overlap destroys them
61shots swallowed by asteroids, 100 points each: the paste never breaks one
81 of 83statements ran; the rest never can, each for a recorded reason

The loop: LOOP OPEN: every hole of ours is closed; 30 owner hole(s), from 15 question(s) only the owner can answer, keep it open. Never ran: ReduceLives#s4; ReceiveTick(BP_Meteor)#s1 - the literal-false side of ReduceLives's DoOnce (the test is the literal false: the DoOnce's Start Closed pin is left at its default in the paste (BP_Character_Lives.t3d:59: no value, no wire), and the macro declares it with no default, which leaves a bool false (StandardMacros.t3d:715-726): its then side never runs) and BP_Meteor's Tick, which BP_Asteorid's supersedes.

It opens playing: the game on the left is the converted code running, and every node it runs glows in the city on the right. Press a key to take over (A / D turn, Space fires); left alone, the computer plays. Open it full screen. The 13 values the pastes do not carry - sizes, speeds, the waves - are this page's, and the game's panel lists each one as authored.

What a whole game took in the converter, each a fix to the class with its evidence: a graph's kind read from its own event nodes (an event stands only in an event graph, K2Node_Event.cpp:523), so a pasted BeginPlay is code; DoOnce's state kept on the object and DecrementInt given its code form (StandardMacros.t3d); the shot's Timeline as an island whose outputs the engine fires each frame; an owner declared in the manifest, with the reason, where a copy cannot say whose it is; and a class renamed between pastes found by its variables' GUIDs (BP_Meteor became BP_Asteorid: its AimVector and Speed keep their GUIDs).

Only the author can answer (15)

  • IR-AS-1 BP_Meteor and BP_Asteorid are one Blueprint, renamed: the asteroid takes its aim from BP_Meteor's ReceiveBeginPlay, and BP_Asteorid's Tick (which adds the growth) supersedes BP_Meteor's
  • IR-AS-2 Every speed is set before play, to values the author names: the asteroid's Speed (BP_Meteor's, the same variable), the enemy bullet's Speed and the ship's RotationSpeed
  • IR-AS-3 How long a ship waits before it may fire (DelayUntilShooting), how fast a hit ship flashes (FlashInterval), and the 0.2 s before the flashing starts, are named design values set before play
  • IR-AS-4 What each target is worth comes from one scoring table: a ship's HitEnemyShipScore is a variable set before play, while an asteroid's 100 is written into its graph
  • IR-AS-5 Each enemy ship's path is a Spline built in its own Blueprint before play
  • IR-AS-6 An enemy ship's speed is a named design value; today the variable Speed is overwritten with 100 every frame, so its default, and any change to it, has no effect
  • IR-AS-7 How large things grow as they leave the middle (the game's perspective) is named design values: an asteroid 0.5 + min(d / 150, 1), a ship 0.1 + min(d / 200, 0.2)
  • IR-AS-8 The asteroid timer runs from the spawner's ReceiveBeginPlay for as long as the spawner lives: nothing in the pastes pauses it, during the flashing or at any point of a game
  • IR-AS-9 Enemy ships come in waves: something starts a looping 0.5 s timer that runs CustomEvent_1, and something ends it, so that a wave holds a number of ships the author names
  • IR-AS-10 An asteroid is never destroyed: a shot that hits it scores 100 and is itself destroyed, and an asteroid that hits the ship costs a life and flies on through
  • IR-AS-11 The ship turns with its controller, and its sprite and muzzle (ProjectileSpawn) sit away from its middle, so that turning the control rotation carries them around a ring
  • IR-AS-12 The player character is always a BP_Character and the player controller a BP_Controller (the game mode's defaults), so every cast to them succeeds; were one to fail an asteroid or a bullet would keep its default aim, the title would mark nothing and a lost life would hide no icon
  • IR-AS-13 A shot's flight takes as long as its Timeline and follows its track NewTrack_0, and the component that moves (RenderComponent) is the one that collides
  • IR-AS-14 What the pastes name but do not hold is built as its name says: the score widget BP_Score (UpdateScore, the icons Life1-3), the explosion BP_Explosion, and the controller's DestroyUI
  • IR-AS-15 The ship starts with Lives = 3: three icons to lose, and the fourth hit ends the game
SHEET 0

Observational understanding: a city you can fly through

Drag to orbit, scroll to zoom, W A S D to fly; point at anything to name it and click it for what it is, a node for its whole chain. Type ask what happens when the locked target dies, questions, fly to ConeCycle or play. Exec pipes run above the nodes and data pipes below. The two graphs a timer runs 100 times a second burn red, and a call made by a function's name marches in orange. Open it full screen. Or press Mic and say it (Chrome, Edge and Safari hear speech). The whole Blueprint as code is one click away.

162 / 162Blueprint nodes traced to a use case step
54paths through the code: 48 covered, 6 excluded with a reason
54 / 54brainstorm questions answered (15 rules)
18questions only the author can answer
27.2xfewer tokens than the whole code to answer a question
75 / 75real-data test rows passing
SHEET 1

What was pasted

Lock-On System (121 nodes) · Distance To Frank (12 nodes) · Toggle Lock On (5 nodes) · New Control Rotation (24 nodes). Measured in the author's own layout: 200 wires with 29 crossings, 17 of them an exec wire over a data wire. There are no comments. Two timers call functions by a name in a string (DistanceToFrank, ToggleLockOn) every 0.01 s. The paste names no parent class.

SHEET 2

The same logic as classes and code

The converter read all 162 nodes, as the engine reads them: object paths, event names, the macros, and a pin that defaults to self. It wrote 99 statements in 12 methods, and each one parses as C#. Then the methods were assembled into the classes they belong to. Each parent class was READ from what the Blueprint uses on itself: FrankBP : Character, with 11 typed fields, 11 methods and its two components, and MasterEnemy : Actor, the Blueprint DistanceToFrank's own paste names as its self. The event graph casts to Master_Enemy, an asset at another path, so the two are held apart as read: one Blueprint moved and renamed, or two, is the author's to say. The toolkit's own UML gate holds that class model to the code.

classDiagram
  class LockOnInterface {
    <<interface>>
    +LockOnInterface()
  }
  class MasterEnemy {
    +float DistanceToFrankVar
    +bool CanBeTargeted
    +DistanceToFrank()
  }
  Actor <|-- MasterEnemy
  class FrankBP {
    +bool LockedOn
    +double ClosestTargetDistance
    +Master_Enemy EnemyElement
    +Master_Enemy LockedOnTarget
    +double MaxDistance
    +Rotator RotationInstance
    +bool NoFalse
    +List~Master_Enemy~ Out_Actors
    +List~Master_Enemy~ ConeActors
    +Rotator LockOnTargetRotator
    +Vector TargetLocation
    +LockON()
    +BndEvt__BP_TopDownCharacter_Sphere_K2Node_ComponentBoundEvent_0_ComponentBeginOverlapSignature__DelegateSignature()
    +BndEvt__BP_TopDownCharacter_Sphere_K2Node_ComponentBoundEvent_1_ComponentEndOverlapSignature__DelegateSignature()
    +LockOnDone()
    +SetLockOnTarget()
    +EnemyDeath()
    +BndEvt__FrankBP_LockOnCone_K2Node_ComponentBoundEvent_2_ComponentBeginOverlapSignature__DelegateSignature()
    +BndEvt__FrankBP_LockOnCone_K2Node_ComponentBoundEvent_3_ComponentEndOverlapSignature__DelegateSignature()
    +ConeCycle()
    +NewControlRotation()
    +ToggleLockOn()
  }
  Character <|-- FrankBP
  FrankBP *-- PrimitiveComponent : LockOnSphere
  FrankBP *-- PrimitiveComponent : LockOnCone
  class Master_Enemy {
    +float Distance_to_Frank_Var
    +bool IsDead
  }
  FrankBP ..> LockOnInterface : messages
classDiagram
  class LockOnInterface {
    <<interface>>
    +float Distance_to_Frank_Var
    +bool IsDead
    +void LockOnInterface(Master_Enemy Locked_On_Target)
  }
  LockOnInterface <|.. Master_Enemy
  class LockOnSystemComponent {
    -LockedOn
    -ClosestTargetDistance
    -EnemyElement
    -LockedOnTarget
    -MaxDistance
    -RotationInstance
    -NoFalse
    -Out_Actors
    -ConeActors
    -LockOnTargetRotator
    -TargetLocation
    +LockON()
    +On_Component_Begin_Overlap_LockOnSphere_()
    +On_Component_End_Overlap_LockOnSphere_()
    +LockOnDone()
    +SetLockOnTarget()
    +EnemyDeath()
    +On_Component_Begin_Overlap_LockOnCone_()
    +On_Component_End_Overlap_LockOnCone_()
    +ConeCycle()
    +NewControlRotation()
    +ToggleLockOn()
  }
  FrankBP *-- LockOnSystemComponent
  Character <|-- FrankBP
  LockOnSystemComponent --> LockOnInterface : asks, never casts

Left: as read. Right: the OO shape proposed for what the brainstorm found. It is a design, and nothing here rewrites the Blueprint.

SHEET 3

Human ergonomics: each friction the discussion names, measured

The view's layout of the same graphs: 148 wires, 0 spanning six or more statements, 0 nodes moved between two layouts. Every figure below comes from tools/friction.py, none typed by hand.

The Spaghetti Wire Effect

The design discussion arguesText code reads top to bottom, but a Blueprint carries every value on a wire, so one variable used by several distant nodes sends wires across everything else.
In this Blueprintthe author's own layout: 200 wires (82 exec, 118 data) with 29 crossings between wires of one graph; the longest 1509 units (straight segments between node positions - the text carries no node sizes)
In the viewthe view lays the same graphs out from the code's structure: 148 wires drawn, 0 spanning 6 or more statements, 0 nodes moved between two layouts, longest 1011 px (layout gate PASS); a value read far away gets a getter beside its reader instead of a wire
ANSWERED (measured)

Scale and Zoom Blindness

The design discussion arguesA large graph forces a choice: zoom out until the nodes cannot be read, or zoom in to fix a detail and lose the flow around it.
In this Blueprintthe event graph spans 2736 x 2160 units of canvas; finding one node means panning it
In the viewfly to any of 99 statements by name or text, one command, typed or spoken; island titles carry the map from far away and node labels fade in as you come close; 'ask' hands back only the slice that answers (results/RAG-LOCKON.md:16 At budget 3000 (the smallest that answers all 10): RAG 9053 tokens against CODE 246150 and RAW 1642300 - 27.2x fewer than the converted code, 181x fewer than the raw text.)
ANSWERED (measured)

Execution vs. Data Clutter

The design discussion arguesTwo kinds of wire share one canvas, exec wires that order events and data wires that carry values, and where they cross the logic is hard to follow.
In this Blueprint17 of those crossings are an exec wire over a data wire
In the viewin 3D the two never share a plane: exec pipes run above the nodes (lowest point y=0.466), data pipes below them (highest point y=0.125) - a 0.34-unit gap, so no exec pipe can cross a data pipe (view3d.js buildIsland)
ANSWERED (by construction)

The Hiding of the Hierarchy

The design discussion arguesA child Blueprint inherits everything from its parent yet opens on an empty graph, and the parent's logic is reached only through an explicit call node.
In this Blueprintthe pasted text names no parent class for either Blueprint
In the vieweach class is a district standing over its engine parent's floor, the parent READ from what the class uses on itself: MasterEnemy : Actor; FrankBP : Character (oo.js, the engine headers that declare those members)
ANSWERED (read, not drawn by hand)

The Lack of Encapsulation

The design discussion arguesText code hides a long chain of logic behind one method call; Blueprints tend to copy the whole chain into every graph that needs it, erasing the class boundary.
In this Blueprint1 rule written twice by the trace's count (SetLockOnTarget#s1:then) - it is one run of Blueprint nodes the converter prints once per path, not the author's; 3 events fired like functions; 3 members written by several graphs
In the viewassembled as classes (typed fields, methods, components), and each pattern named with the OO form that removes it: 8 proposals, each tied to the questions that found it (CLASSES.md)
ANSWERED for reading and planning; the view does not rewrite the Blueprint

The Casting Trap

The design discussion arguesPolymorphism lets code treat a child as its parent, but Blueprints lean on explicit Cast To nodes, so what should be one interface call becomes a roadblock in the graph.
In this Blueprint4 Cast To nodes test an actor's class before every use
In the viewthe proposed shape replaces them with an interface the cast class implements, holding exactly the members the code reads through the cast (LockOnInterface: float Distance_to_Frank_Var { get; }, bool IsDead { get; }, void LockOnInterface(Master_Enemy Locked_On_Target))
PROPOSED (a design, not a change)

The Multi-Dimensional Grid Problem

The design discussion arguesText stays compact through nested names; drawn as nested boxes, the same structure becomes a map to pan and zoom through just to find one variable.
In this Blueprintthe logic sits in 12 graphs across 4 pasted texts; a member like LockedOn is written in 4 of them
In the viewone command reaches any of them; the members panel lists every field with who writes and names it; the retrieval layer answers a question from the trace without opening a file (results/RAG-LOCKON.md:16 At budget 3000 (the smallest that answers all 10): RAG 9053 tokens against CODE 246150 and RAW 1642300 - 27.2x fewer than the converted code, 181x fewer than the raw text.)
ANSWERED (measured)

Invisible Relationships

The design discussion arguesText keeps relationships such as inheritance abstract; drawing each one as a pipe back to its parent would bury the graph in lines.
In this Blueprint5 calls are made by a function NAME in a string (DistanceToFrank, ToggleLockOn) - no reference the editor can find
In the viewevery call between graphs is an arc; a call by name marches in orange and says so; the interface is a ring the 6 messages go through; the parent is a floor, not a pipe per member
ANSWERED (drawn from the trace)

Encapsulation Gates

The design discussion arguesA strictly object-oriented graph would turn reading one value into a chain of reference, getter and access nodes, filling the screen with boilerplate.
In this Blueprint43 of 162 Blueprint nodes are variable reads and pure math - boilerplate a strict OO graph would multiply
In the viewthey are written INTO the statement that reads them (as the engine compiles a pure node in front of its reader), so a getter is a word in a line, not a node to wire
ANSWERED (measured)

Voice-to-Code Input

The design discussion arguesSaying what should happen, instead of searching menus for nodes, could drive the code, with the graph as the display of the result.
In this Blueprintevery look in Unreal is a click, a pan or a search box
In the viewa command bar takes typed or spoken commands (the browser's speech recognition where it is offered: 19 of 22 spoken commands heard and run, a synthesized voice played to Chrome 156.0.8078.49 as its microphone (results/DICTATION.md)); changes are typed commands on the code through three gates (tools/edit.py, P6a)
PARTLY: commands yes; speaking a CHANGE, not yet

The "Icing" Concept

The design discussion arguesThe visual layer is icing over the real code, but load-bearing icing: people remember where things are, so a generated map aids pattern finding and debugging.
In this Blueprintthe Blueprint is the only form of this logic
In the viewthe visual map is generated from the code and never edited apart from it: every one of the 162 nodes becomes a graph node and maps to a requirement (S-BP spaces, 162/162), and the city is laid out from the code's structure, so it stays where the reader remembers it (0 nodes moved between two layouts)
ANSWERED (measured)

Data as Flowing Water

The design discussion arguesThe graph could show execution as pulses and data as flow, a pipe's thickness for its type's weight and a swollen red pipe where the code bottlenecks.
In this BlueprintDistanceToFrank runs 100 times a second (OnComponentBeginOverlap(LockOnSphere)#s3); ToggleLockOn runs 100 times a second (SetLockOnTarget#s14) - nothing in the editor shows that cost
In the viewpulses run the exec pipes; those two graphs burn and pulse red at their timers' rate; data pipes are as thick as their type is heavy (a Vector or Rotator thick, a bool thin) and coloured like Blueprint pins
ANSWERED (rates READ from the timers)

Time-Travel Auto-Replay

The design discussion arguesIf the engine kept a rolling record of execution, a failure could be replayed and scrubbed to the moment the data went wrong instead of guessed at.
In this Blueprintthe editor shows a value only at a breakpoint, live, one at a time
In the viewevery one of the 54 paths through the graphs replays step by step, scrubbed back and forth, each step naming the use case step and requirement it serves; with VALUES for the battles of a game in production: measured in the experiment's records
ANSWERED for paths; VALUES on the replays of a game in production (the sample cannot run: its enemy class is not in the pastes)

Coding via Observation

The design discussion arguesSeeing values flow invites changing them in place: a value adjusted on a wire, and the running game answering at once.
In this Blueprintchanging a value means editing, compiling and playing again
In the viewon the replays of a game in production a valve changes a value at a probe and re-runs every battle with no rebuild: measured in the experiment's records
ANSWERED on the replays of a game in production; ABSENT on the sample (no run to change)
SHEET 3B

One more, chosen for its friction: a whole enemy AI

JJ GameDesign's Enemy Blueprint for Antagonist Combat System (blueprintue.com, UE 5.3): the whole event graph of one enemy, 1,009 nodes in one paste. Why this one: it is classic spaghetti on every axis the Lock-On instruments take, with 6.2 times Lock-On's nodes, and each of its graphs sits in one of the author's 25 comment boxes, so the requirements have a second source. The same frictions, measured with the same instruments as Lock-On's above; each card says what the view answers and what it does not. Fly it in the city.

Measured the same wayLock-OnThis enemy
nodes in the paste(s)162 in 4 pastes1009 in 1 paste
wires as drawn (exec, data)200 (82, 118)1090 (496, 594)
crossings as drawn (exec over data)29 (17)174 (108)
longest wire as drawn, units15094164
largest canvas, units2736 x 216018880 x 12146
the view's layout: wires, long wires, nodes moved, longest px148, 0, 0, 1011851, 0, 0, 2740
graphs, statements, nodes folded into the statement that reads them12, 99, 4336, 629, 451
decisions, outcomes, entry-to-exit paths30, 60, 54119, 241, 270
Cast To nodes43
calls between graphs (by a name in a string)13 (5)55 (0)
member written by the most graphsLockedOn, 4Health, 5
brainstorm questions raised54237 (CONST 8, DUP 6, ELSE 71, EVENTCALL 26, LITERAL 78, UNWRITTEN 7, WRITE 41)
graphs a timer runs at a rate the city burns red20
deepest branch nesting (decisions inside decisions, from the graph files)6 (LockON#s20)5 (Toxic_Hit#s10)
exec wires drawn right to left in the author's layout1 of 8227 of 496
longest entry-to-exit path, statements13 (LockON#P4)35 (DisolveTimer#P1)

The Spaghetti Wire Effect

In this Blueprintthe author's own layout: 1090 wires (496 exec, 594 data) with 174 crossings between wires of one graph; the longest 4164 units (straight segments between node positions - the text carries no node sizes)
In the viewthe same graphs laid out from the code's structure: 851 wires drawn, 0 spanning 6 or more statements, 0 nodes moved between two layouts, longest 2740 px (layout gate PASS); a value read far away gets a getter beside its reader instead of a wire
Not solvedthe converter writes a node that several exec wires reach once per path: 94 shared steps are written again, so the code is longer than the graph there and one Blueprint node shows as several statements
ANSWERED (measured)

Scale and Zoom Blindness

In this Blueprintthe event graph spans 18880 x 12146 units of canvas, 1009 nodes in one graph; finding one node means panning it
In the viewfly to any of 652 statements by name or text, one command, typed or spoken; island titles carry the map from far away; 'ask' hands back a slice of the trace (results/ENEMYAI_RAG.md:11 - budget 3000: 7 of 10 questions keep every key; 8907 tokens in all (891 per question) - missing: R4 Attack_Index, both included; R5 Delay(4f), Delay(3f); R7 AbilityDamageCounter, back at 0)
Not solvedthe retrieval slice at Lock-On's smallest budget (results/RAG-LOCKON.md:11 - budget 3000: 10 of 10 questions keep every key; 9053 tokens in all (905 per question)) misses keys here, and still at the widest budget swept (results/ENEMYAI_RAG.md:19 - budget 48000: 9 of 10 questions keep every key; 85467 tokens in all (8547 per question) - missing: R7 AbilityDamageCounter, back at 0)
ANSWERED for finding; PARTLY for asking

Execution vs. Data Clutter

In this Blueprint108 of those crossings are an exec wire over a data wire
In the viewin 3D the two never share a plane: exec pipes run above the nodes, data pipes below them (view3d.js buildIsland; the same separation measured for Lock-On), so no exec pipe can cross a data pipe
Not solvedthe 3D city draws 851 wires for 36 graphs at once; the separation removes exec-over-data crossings, not the count of pipes a reader faces
ANSWERED (by construction)

The Hiding of the Hierarchy

In this Blueprintthe pasted text names no parent class for Enemy_AI_BP
In the viewthe class is assembled from what it uses on itself, and its parent READ from the engine's headers - every class that declares one of those members, weighed by how many of them its chain declares - with the paste's own Target pins agreeing: Enemy_AI_BP is a Character or a child of it (CapsuleComponent at Character.h:263 and CustomTimeDilation at Actor.h:761, the lines read again here from the headers); the 7 members no class on that chain declares are its own, components or variables its paste does not declare (DamageIndicator, TextRender, LevelText, LevelText:, Healthbar Widget, Arrow1, Arrow2), each Target pin naming Enemy_AI_BP itself
Not solvedthe parent read is the nearest NATIVE class: a Blueprint between Enemy_AI_BP and Character, if there is one, is not in the paste, so the view says a Character or a child of it
ANSWERED (read from the engine's headers; the paste's Target pins agree)

The Lack of Encapsulation

In this Blueprint6 rules written twice by the trace's count - 3 of them copies the author made (Q-DUP.FireStatChecker#s1:else, Q-DUP.Swing_down#s22:then, Q-DUP.Swing_down#s39:then - the copies of Q-DUP.Swing_down#s22:then again, on another path), 3 one Blueprint node the converter prints once per path (Q-DUP.AbilityDamageInfo#s10:then, Q-DUP.AbilityDamageInfo#s15:else, Q-DUP.DisolveTimer#s7:then); 26 events fired like functions; 41 members written by several graphs
In the viewassembled as a class (typed fields, methods, components), and each pattern named with the OO form that removes it: 46 proposals, each tied to the questions that found it (CLASSES.md); of the rules written twice, 2 are proposed as a method of their own (Q-DUP.FireStatChecker#s1:else, Q-DUP.Swing_down#s22:then) and 4 are listed apart as the converter's, not the author's (CLASSES.md)
ANSWERED for reading and planning; the view does not rewrite the Blueprint

The Casting Trap

In this Blueprint3 Cast To nodes (ReceiveBeginPlay#s1, ReceiveBeginPlay#s3, ReceiveBeginPlay#s5), each inside the one before; the player's character, kept from the first, is read in 11 graphs
In the viewthe proposed shape replaces each cast with an interface holding exactly the members read through it (DamageIndicator for BP_LearningKit_PlayerCharacter; IDamageIndicator_UI for DamageIndicator_UI; IAI_Healthbar for AI_Healthbar); a Blueprint interface's name is kept only for a type the pastes message it on (DamageIndicator, sent to a BP_LearningKit_PlayerCharacter at Enemy_AI_BP.t3d:4659)
Not solved2 of the 3 proposed interfaces hold no member (IDamageIndicator_UI, IAI_Healthbar): the class model collects the Blueprint variables read through a cast and the interfaces messaged on it, not the functions called on it or the members it declares without a guid (its widgets and components)
PROPOSED (a design, not a change)

The Multi-Dimensional Grid Problem

In this Blueprintthe logic sits in 36 graphs of 1 pasted text; a member like Health is written in 5 of them
In the viewone command reaches any of them; the members panel lists every field with who writes and names it; the retrieval layer answers from the trace without opening a file (results/ENEMYAI_RAG.md:11 - budget 3000: 7 of 10 questions keep every key; 8907 tokens in all (891 per question) - missing: R4 Attack_Index, both included; R5 Delay(4f), Delay(3f); R7 AbilityDamageCounter, back at 0)
Not solvedsee Scale and Zoom Blindness: at this size the retrieval slice drops part of an answer
ANSWERED for reaching; PARTLY for asking

Invisible Relationships

In this Blueprint55 calls between graphs, 0 by a name in a string; 4 interface messages and 5 interface tests (DoesImplementInterface) instead of a typed reference
In the viewevery call between graphs is an arc; the interfaces are rings the messages go through (DamageIndicator 3, Stun_BPI 1)
Not solved10 of the 36 graphs are entered by no call in the paste: 3 by the engine (ReceiveBeginPlay, ReceiveTick, OnSeePawn(PawnSensing)) and 7 from Blueprints that were not pasted (TakenDamage, Burning, FrozeActor, InspectInfo, Check_For_Reincarnation, Ambush_Intro, Level_Up); the city draws no arc into them, so who starts an enemy is not on screen (IR-EN-4)
ANSWERED (drawn from the trace)

Encapsulation Gates

In this Blueprint451 of 1009 Blueprint nodes are variable reads and pure math - boilerplate a strict OO graph would multiply
In the viewthey are written INTO the statement that reads them (as the engine compiles a pure node in front of its reader), so a getter is a word in a line, not a node to wire
ANSWERED (measured)

Voice-to-Code Input

In this Blueprintevery look in Unreal is a click, a pan or a search box
In the viewthe city's command bar takes typed or spoken commands (19 of 22 spoken commands heard and run, a synthesized voice played to Chrome 156.0.8078.49 as its microphone (results/DICTATION.md)); changes are typed commands on the code through three gates (tools/edit.py)
PARTLY: commands yes; speaking a CHANGE, not yet

The "Icing" Concept

In this Blueprintthe Blueprint is the only form of this logic
In the viewthe visual map is generated from the code and never edited apart from it: every one of the 1009 nodes is reached by a use case step or excluded with its reason (S-BP space: 984 mapped, 25 excluded - the comment boxes), and the city is laid out from the code's structure (0 nodes moved between two layouts)
ANSWERED (measured)

Data as Flowing Water

In this BlueprintReceiveTick runs every frame and calls Check_Player_Range, Landed, Reset_Character from it; Rotate_Text, Enraged_Particles, DisolveTimer re-run themselves through a 0.01 s Delay, which counts down once a frame (DelayAction.h:27-30)
In the viewpulses run the exec pipes; data pipes are as thick as their type is heavy and coloured like Blueprint pins; a graph that runs often burns red - a timer's at the timer's rate (here 0: no timer in the paste), and the Tick graph and the 8 Delay loops by the rate READ into the city's data, said on each one's entry: ReceiveTick once a frame; DisolveTimer, Enraged_Particles, Rotate_Text at most every 0.01 s; Attack_Combo, Burning at most every 0.2 s; Landed, Random_Roam at most every 0.8 s; AbilityDamageInfo at most every 2 s (view/scene_cli.js GraphRuns, view/view3d.js buildIsland)
ANSWERED (every rate READ; each graph that runs often burns)

Time-Travel Auto-Replay

In this Blueprintthe editor shows a value only at a breakpoint, live, one at a time
In the viewevery one of the 270 paths through the graphs replays step by step, scrubbed back and forth, each step naming the use case step and requirement it serves
Not solveda value replay needs what the paste does not hold - the two data tables, the montages, the player's Blueprint and the level that starts the enemy - so none is run (no value invented); value replays are measured on another code base (results/FRICTION_LOCKON.md)
ANSWERED for paths; VALUES not on this sample

Coding via Observation

In this Blueprintchanging a value means editing, compiling and playing again
In the viewon a code base with runnable replays, a valve changes a value at a probe and re-runs with no rebuild (results/FRICTION_LOCKON.md)
ABSENT on this sample (no run to change)
SHEET 4

From one node to the requirement it serves

Every piece of the Blueprint links to the use case step it realises, and the steps form a linear, hierarchical chain. Here is one node, as the city's details panel shows it.

The loop is closed by counts, as code coverage closes it, and the toolkit's existing gap checker gates them. All 162 nodes are mapped. Of 60 decision outcomes, 58 are cited and 2 are excluded because they cannot happen. Of 54 paths, 48 are covered and 6 excluded. All 54 brainstorm questions are answered.

SHEET 5

Closed loop requirements: the loop an AI acts on

The design rule: closed-loop requirements replace the code as what an AI acts on, so it works from the loop rather than from prompts, and no mistake gets through unless the requirements carry it too. The node was judged by one question: what mistake can still get past it? Thirteen criteria answer it, each named by the mistake it stops, and 6 of them could not be held at all before today. Three additions to the node made all 13 measurable. The effect says, in the code's own terms, what each requirement makes the code set, call, branch on or read, and where. The terms bind each word of the requirements to the code names it means. The lock records each requirement's fingerprint as last verified.

6 of 13criteria the node could not hold before
0holes of ours now (the gate fails on one)
84assertions of 25 READ requirements hold against the code
13assertions from the owner's questions fail on the code as pasted
97 / 97verdicts flipped by their own plant
18owner questions keep the loop open (43 holes)
criterionthe mistake it stopsbefore 10-28now: ours / owner / listed
L1 IDENTITYa rebuild points an edge at another node, and a verdict follows the wrong thing0 / 0 / 00 / 0 / 0
L2 SOURCEDa requirement nothing outside the model states, or a cell dropped with no reason0 / 0 / 00 / 0 / 0
L3 CORROBORATEDa requirement only one family states inherits that family's mistakes (listed)0 / 0 / 110 / 0 / 11
L4 CARRIEDa requirement no pathway an epic reaches realises: nobody builds it0 / 0 / 00 / 0 / 0
L5 ENDEDa pathway with no end or no actor, a step carrying nothing: behaviour nobody specified0 / 0 / 00 / 0 / 0
L6 ANSWEREDa question nobody answered, settled by a guess0 / 18 / 00 / 18 / 0
L7 REALIZEDcode linked to the right requirement that does the wrong thingnot held: no field for it0 / 21 / 0
L8 FALSIFIABLEa check that passes whatever the code doesnot held: no field for it0 / 0 / 0
L9 JUSTIFIEDcode no requirement asked for: behaviour that slipped in0 / 0 / 00 / 0 / 0
L10 DEFINEDa requirement naming what the code does not have, or a word read two waysnot held: no field for it0 / 4 / 4
L11 CAUSALa step relying on a condition nothing makes truenot held: no field for it0 / 0 / 0
L12 CONSISTENTtwo requirements demanding opposite effects: meeting one breaks the othernot held: no field for it0 / 0 / 0
L13 CHANGE-SAFEa requirement, or the code it reads, changed after it was verifiednot held: no field for it0 / 0 / 0

What the loop caught in the code

  1. assert:IR-LO-1#1calls IsValid with LockedOnTarget at LockON#s21:then (no statement at LockON#s21:then calls IsValid (read 3))
  2. assert:IR-LO-1#2calls IsValid with LockedOnTarget at LockON#s31:then (no statement at LockON#s31:then calls IsValid (read 3))
  3. assert:IR-LO-3#1sets Out_Actors by Array_AddUnique at OnComponentBeginOverlap(LockOnSphere)#s1:then (no statement at OnComponentBeginOverlap(LockOnSphere)#s1:then sets Out_Actors (read 5))
  4. assert:IR-LO-3#2sets ConeActors by Array_AddUnique at OnComponentBeginOverlap(LockOnCone)#s1:then (no statement at OnComponentBeginOverlap(LockOnCone)#s1:then sets ConeActors (read 1))
  5. assert:IR-LO-5#1branches LockedOnTarget at EnemyDeath (no statement at EnemyDeath branches LockedOnTarget (read 2))
  6. assert:IR-LO-6#1calls GetDistanceTo at DistanceToFrank (no statement at DistanceToFrank calls GetDistanceTo (read 4))
  7. assert:IR-LO-7#1branches LineTraceSingleForObjects at DistanceToFrank (no statement at DistanceToFrank branches LineTraceSingleForObjects (read 4))
  8. assert:IR-LO-8#1calls LineTraceSingleForObjects with EDrawDebugTrace.None at DistanceToFrank#s1 (no statement at DistanceToFrank#s1 calls LineTraceSingleForObjects (read 1))
  9. assert:IR-LO-11#1calls K2_SetTimerDelegate at OnComponentBeginOverlap(LockOnSphere)#s1:then (no statement at OnComponentBeginOverlap(LockOnSphere)#s1:then calls K2_SetTimerDelegate (read 5))
  10. assert:IR-LO-14#1calls GetWorldDeltaSeconds at NewControlRotation#s1:then (no statement at NewControlRotation#s1:then calls GetWorldDeltaSeconds (read 7))
  11. assert:IR-LO-15#1calls LockOnInterface at OnComponentBeginOverlap(LockOnSphere)#s4:then (no statement at OnComponentBeginOverlap(LockOnSphere)#s4:then calls LockOnInterface (read 2))
  12. assert:IR-LO-15#2calls LockOnInterface at OnComponentEndOverlap(LockOnSphere)#s5:then (no statement at OnComponentEndOverlap(LockOnSphere)#s5:then calls LockOnInterface (read 2))
  13. assert:IR-LO-17#1sets Distance_to_Frank_Var at DistanceToFrank#s2 (no statement at DistanceToFrank#s2 sets Distance_to_Frank_Var (read 1))

The loop's honest limit is the rule's own caveat, counted: 11 requirements rest on the code alone (L3), so a mistake already in the code is in them too. Change safety was tested on a copy of this sample: an edited requirement, and a changed statement it reads, each came back STALE. Generated from two runs of the gate: results/LOOP_LOCKON.md.

SHEET 6

What only the author can answer

These are the gaps the chain found: things the code does that nobody decided, each with the question for its author. Most are defects.

  1. IR-LO-1A search that finds no candidate closer than 4000 must not keep a target an earlier event left, nor ask whether a missing target is dead
  2. IR-LO-2NoFalse must record something the search finds; today every candidate sets it to true, so its test after the loop always passes
  3. IR-LO-3An enemy must be listed once even when two of its parts overlap the range or the cone
  4. IR-LO-4LockON, LockOnDone and SetLockOnTarget are events fired like function calls: decide whether they are functions
  5. IR-LO-5When the target dies the lock must move on or end; today nothing releases it and the facing update keeps running
  6. IR-LO-6The distance must be to Frank, not to whatever the trace hits first
  7. IR-LO-7An enemy whose trace hits nothing must not read as 0 units away
  8. IR-LO-8The distance trace must not draw debug lines in a shipped game
  9. IR-LO-9What an enemy does when told it is (or is no longer) the target is not in the pastes
  10. IR-LO-10The two copies disagree: ToggleLockOn's call expects a second output (Character) that NewControlRotation does not declare
  11. IR-LO-11Functions a timer runs must be called so that a rename is caught
  12. IR-LO-12Say which is the lock range: the 4000 a search starts from, or MaxDistance
  13. IR-LO-13The update rate (0.01 s) is written into three timers: one setting or three?
  14. IR-LO-14The turn smoothing must match the update rate: it assumes 0.1 s between updates while they come every 0.01 s
  15. IR-LO-15Choosing the lock again (an enemy enters, the target leaves) must tell the old target it is no longer the target
  16. IR-LO-17The search must read the distance the enemy measures: as pasted, the enemy writes DistanceToFrankVar and the search reads Distance to Frank Var - two different variables
  17. IR-LO-18Whoever kills an enemy must set its IsDead, and the order against EnemyDeath must be said
  18. IR-LO-16The player must learn when a lock fails: nobody close enough, or the chosen target dead
SHEET 7

The ideas, measured

The graph as retrieval

Answering a question takes the few pieces of the trace it touches: 9053 tokens for 10 questions, against 246150 for the converted code and 1642300 for the raw paste. That is 27.2x and 181x fewer, with every answer's key facts kept. Five held-out questions gave the same result.

Reasoning checked against the graph

My first reading of this code, written before the graph existed, made six claims. All six are anchored in the graph and 6 are supported by it. The graph holds 9 of 18 owner questions that reading never saw, including a variable the search reads that nothing writes.

A graph network as a suggester

Message passing over the graph proposes the step a statement belongs to: 86.9% right, against 73.7% for the nearest-cite baseline, and 99.0% against 97.0% for the use case. It is kept as a suggester. It never decides coverage.

Unreal's editor, panel by panel

The engine names 15 Blueprint-editor panels. 9 have an answer here. The rest are absent, each for a reason:
  • Class Defaults (DefaultEditorID): a clipboard copy carries no defaults (the sample's MaxDistance is read, never valued); an export does - whether to show them is an open product decision (IR-17)
  • Palette (PaletteID): no node is placed by hand: a change is a typed command on the code, through three gates (tools/edit.py, P6a, ED-2)
  • Viewport (SCSViewportID): the components' meshes and transforms live in the Blueprint asset, not in the graphs a person pastes - drawing them in place is an open product decision (IR-18)
  • Replace References (ReplaceNodeReferencesID): the view does not edit Blueprints; a rename goes through the C#, where the compiler finds every reference - and a call by NAME is flagged (Q-NAME), the one kind the engine cannot find
  • Timeline editor (TimelineEditorID): a Timeline has no code form: the converter keeps it as a marked island (BC-9); there are no curves to edit
  • User Defined Structure (UserDefinedStructureID): a struct's definition is an asset of its own, not a graph; structs reach the view as Make/Break nodes (BC-6)
SHEET 8

How it folds into u2ue

py -m u2ue blueprint doctor      # every prerequisite, found or missing with its install command
py -m u2ue blueprint install     # prints those commands; runs them only with --yes
py -m u2ue blueprint test        # 75 rows on real data: the online paste, Epic's templates, the game's own code
py -m u2ue blueprint gates       # names, orphans, the models, the frictions, the retrieval, the chains, the closed loop
py -m u2ue blueprint build <set> "<title>"   # a paste set end to end, into the city, ending on the loop's verdict

It is one verb in the toolkit's single registry, with self-test rows that u2ue check runs. The existing gap checker gained a code basis instead of a second checker being written, and uml.py and morph_box.py are reused. Every file is reached by something that runs and drawn in the class model, so nothing is orphaned. The experiment stays quarantined until a deliberate decision moves it into the toolkit.

SHEET 9

Not done, and why

Sample: Lock-On System (121 nodes) · Distance To Frank (12 nodes) · Toggle Lock On (5 nodes) · New Control Rotation (24 nodes). Analysis only: the pasted text is not republished, the authors keep the rights, and any author's graphs come down on request. Built by the Blueprint view experiment; every figure is read from its result files.