UE5 Studio Seating Chart — Blueprint Graph
Layouts (ASCII)
Monospaced, box‑drawing diagrams you can mirror 1:1 in your graph. Duplicate tiles
left→right. Keep all exec wires flowing →.
Legend
[NodeName]
▸ Exec In → Exec Out ▸
● Data Pin (input) ○ Data Pin (output)
(Var) = variable get [SET Var] = variable set
(R) = Reroute node
Tile A — Rule #2 (Experience < 3)
Function: FillRow_ByExperienceLessThan(Row:int, Threshold:int=3)
(Exec In)
───────────────────────────────────────────────────────────────────────────────┐
▼
[ < (Int) ] [Branch] [Add
(Candidates)]
●A (Var) <Person>Years ──► Condition ○──────────True───────► ●Array (Var)
Candidates
●B (Var) Threshold False ┐ ●Item (Var)
<Person>Name
(fallthrough) │
│
(to next tile’s Compare)◄─┘
Reroute tip: Place a (R) under [Link] to drop the exec to Add(Candidates)
without crossing.
Duplicate this block for each person (Anna → Ian). Chain True exec to the next tile’s < (Int) (or its Branch).
1
Tile B — Rule #3 (Name LEN ≥ 7)
Function: FillRow_ByNameLengthAtLeast(Row:int, MinLen:int=7)
(Exec In)
───────────────────────────────────────────────────────────────────────────────┐
▼
[Len (String)] [ >= (Int) ] [Branch] [Add
(Candidates)]
●String (Var) <Person>Name ──► ●A (from Len) ──► Condition ○──► ●Array (Var)
Candidates
●B (Var) MinLen True ●Item
(Var) <Person>Name
False (fallthrough
to next tile)
Duplicate and chain left→right. False pins remain unused.
Tile C — Rule #4 (Experience ≥ 8)
Function: FillRow_ByExperienceAtLeast(Row:int, MinYears:int=8)
(Exec In)
───────────────────────────────────────────────────────────────────────────────┐
▼
[ >= (Int) ] [Branch] [Add
(Candidates)]
●A (Var) <Person>Years ───► Condition ○──────────True───────► ●Array (Var)
Candidates
●B (Var) MinYears False (fallthrough) ●Item (Var)
<Person>Name
Chain across 9 tiles, then exit to AddSortedToRow.
Function Footer — AddSortedToRow (with built‑in Sort)
Call at the end of each Rule function
2
(From last tile Exec)
────────────────────────────────────────────────────────────────► [Set
SortedNames]
●SortedNames = (Input) Candidates
[Sort (String Array)]
●TargetArray (Var) SortedNames
[ForEachLoop]
●Array (Var) SortedNames
▸ LoopBody
[AddNameToRow]
●Row (Input) Row
●Name (Array Element)
(Back to ForEach Completed)
Alternate Footer — Manual Insertion Sort (if Sort node isn’t available)
(Exec from last tile) → [Make Array] → (Var) SortedNames (empty)
For each Candidate in (Input) Candidates:
[ForLoop]
●FirstIndex = 0
●LastIndex = Length(SortedNames) - 1
▸LoopBody → [Get (SortedNames[Index])] → [ToLower] both → [<= (String)]
True → set (Local) InsertIndex=Index, FoundSpot=true → [Break]
After ForLoop: [Branch] (FoundSpot)
True → [Insert] Candidate at InsertIndex into SortedNames
3
False → [Add] Candidate to SortedNames
After building SortedNames:
[ForEachLoop] SortedNames → [AddNameToRow(Row, ArrayElement)]
Event Graph — OnActorBeginOverlap (TriggerVolumeRef)
Only the player (BP_Bot) can activate.
[TriggerVolumeRef::OnActorBeginOverlap]
●OtherActor ───────────────► [Cast To BP_Bot]
(Exec) ───────────────────►
True
▸─────────────────────────────────────────────────────────────┐
▼
[FillRow_ByExperienceLessThan]
●Row=1 ●Threshold=3
▸───────────────────────────────────────────────┐
▼
[FillRow_ByNameLengthAtLeast]
●Row=2 ●MinLen=7
▸───────────────────────────────────────────────┐
▼
[FillRow_ByExperienceAtLeast]
●Row=3 ●MinYears=8
▸───────────────────────────────────────────────┐
▼
[CheckResults]
Note: First AddNameToRow call auto‑shows the UI.
Event Graph — OnActorEndOverlap (TriggerVolumeRef)
Only the player (BP_Bot) can deactivate.
[TriggerVolumeRef::OnActorEndOverlap]
●OtherActor ───────────────► [Cast To BP_Bot]
(Exec) ───────────────────►
4
True ▸────────────────────────►
[DeactivateSeatingChart]
One‑Screen Layout Suggestion
Arrange tiles left→right, top→bottom by person to avoid crossings:
Row A: Anna | Bill | Charlie
Row B: Dave | Eileen | Frank
Row C: Germaine | Harmony | Ian
Exec flows → across each row, then snakes down to next row. Use (R) reroutes for
any vertical drops.
Expected Final Rows (for your eye‑check)
• Row 1 (<3 yrs): Anna, Bill, Ian
• Row 2 (≥7 letters): Charlie, Germaine, Harmony
• Row 3 (≥8 yrs): Dave, Eileen, Frank
When you walk BP_Bot into the volume, you should see names populate and then “Success!”
after CheckResults.
Wide Layout (1920px+) — Zero Crossings
Three rows of tiles × three people each. Exec snakes ⇢ across, then ↓ to next row.
(Entry Exec)
⇢ [Anna Tile] ⇢ [Bill Tile] ⇢ [Charlie Tile]
│
↓
[Dave Tile] ⇢ [Eileen Tile] ⇢ [Frank Tile]
│
↓
[Germaine Tile] ⇢ [Harmony Tile] ⇢ [Ian Tile] ⇢ [AddSortedToRow]
Reroute anchors (R): - Place an (R) just to the right of each tile’s True pin; route down with a vertical wire to
the start of the next row. - Place a second (R) at the left edge of the next row to re-enter the compare of the
first tile.
5
Spacing: - Horizontal: ~560–640 px per tile. Vertical: ~260–300 px between rows. - Keep Add (Candidates)
directly under the tile’s [Link] to avoid diagonal wires.
Compact Layout (1366px) — Two columns, stacked groups
Use two columns, 5 tiles in Col A, 4 tiles in Col B; connect Col A bottom → Col B top.
Col A (left): Col B (right):
(Entry) ⇢ [Anna] ⇢ [Bill] ⇢ [Charlie] [Dave] ⇢ [Eileen] ⇢ [Frank]
│ │
↓ ↓
[Germaine] ⇢ [Harmony] [Ian] ⇢ [AddSortedToRow]
Tip: Add a vertical (R) gutter between columns to carry the exec without crossing data wires.
Snake‑Flow Diagram — Rule #2 (Experience < 3)
Function: FillRow_ByExperienceLessThan(Row:int, Threshold:int=3)
[< (Int)]─►[Branch]─True─►[Add(Candidates)] [<
(Int)]─►[Branch]─True─►[Add(Candidates)]
▲ │ ▲ │
│ └─False───────────────┐ │
└─False───────────────┐
(Var) Years (fallthrough) │ (Var) Years
(fallthrough) │
(Var) Threshold ▼ (Var)
Threshold ▼
(next tile
compare) (next tile compare)
Repeat 9 tiles → AddSortedToRow(Row, Candidates).
Data pins per tile: - A: <Person>Years , B: Threshold → < (Int) - [Link] →
Add(Candidates).Item = <Person>Name
Snake‑Flow Diagram — Rule #3 (LEN(Name) ≥ 7)
Function: FillRow_ByNameLengthAtLeast(Row:int, MinLen:int=7)
6
[Len]─►[>= (Int)]─►[Branch]─True─►[Add(Candidates)]
[Len]─►[>=]─►[Branch]─True─►[Add]
▲ ▲ ▲ ▲
│ │ │ │
Name MinLen Name MinLen
Chain 9 tiles → AddSortedToRow.
Data pins per tile: - [Link] = <Person>Name - >= : A = [Link], B = MinLen - [Link] =
<Person>Name
Snake‑Flow Diagram — Rule #4 (Experience ≥ 8)
Function: FillRow_ByExperienceAtLeast(Row:int, MinYears:int=8)
[>= (Int)]─►[Branch]─True─►[Add(Candidates)] [>=]─►[Branch]─True─►[Add]
▲ │ ▲ │
│ └─False───────────────┐ │ └─False───────────┐
Years, MinYears (fallthrough) │ Years, MinYears (fallthrough)│
▼ ▼
(next tile compare) (next
tile compare)
Finish → AddSortedToRow(Row, Candidates).
Reroute (R) Placements — Visual Guide
[Branch]
True ──► (R1) ──► (R2) ──► [Add(Candidates)]
│
└────────► down to next row start (R3) ──► (R4) ──► [Next Tile
Compare]
- R1: inline at [Link]’s y‑level. - R2: directly above Add(Candidates) input to drop straight down. - R3:
below tile, aligned with the left margin of next row. - R4: at the input edge of the next tile’s compare to enter
horizontally.
7
Per‑Rule One‑Screen Layouts (fit on 1080p)
Rule #2: three rows of three tiles; footer call at bottom‑right.
Rule #3: two rows of five tiles (last is AddSortedToRow).
Rule #4: three rows of three tiles; footer bottom‑right.
Zoom preset: 0.75–0.8 so everything is visible without scroll.
