Overlap Warden - Clears the Unreal Overlap Flags That Can Never Fire, Then Re-Scans to Prove It

Every component with bGenerateOverlapEvents set is paying broadphase bookkeeping every time it moves. On a real project, a large share of them can never raise an overlap at all.

The flag defaults on for many component types. An artist sets a decorative mesh to NoCollision, the mesh stops being able to overlap anything, and the flag stays exactly where it was — invisible in the Details panel unless you already know to look. Nothing in the editor surfaces it, so it accumulates for the entire life of the project.

Switching it off by hand means knowing that nothing, anywhere, consumes that overlap. Nobody can know that by inspection, so nobody touches it.

Overlap Warden proves it, per component, and only where the proof needs no guesswork.

The proof is the engine's own condition, not our opinion of it

Unreal raises an overlap for a component only when both of these hold:

GetGenerateOverlapEvents()  &&  IsQueryCollisionEnabled()

Overlap Warden clears the flag only where query collision is disabled — components for which the engine could never have dispatched an overlap in the first place. Clearing those cannot change behaviour, because there was no behaviour there to change.

The proof sheet draws that conjunction for every component as a two-link chain with the break marked, so across hundreds of rows you read a column of pictures instead of a column of sentences.

The part to judge it on is what it REFUSES

This tool edits components in a level you are going to ship, and the dangerous failure is not missing an offender — that costs you nothing you were not already paying. It is clearing a flag something depended on, which is a trigger volume that quietly stops firing, with no error, no warning and no log line, found weeks later.

And the hazard is worse than it first looks, because the overlap relation is bilateral. Clearing the flag on component A does not merely stop A notifying anyone — it destroys the overlap events of every component B that overlaps A, including a B whose own flag is set and whose listener is live.

That single fact rules out the obvious implementation. A per-component analysis of the form "is anything bound to A's delegates?" is unsound, however confident it looks.

So Overlap Warden acts only where no pairing argument is required at all, and refuses everything else by name, with the signal it could not establish. A signal that was not measured is never treated as an absent one. The refusal list is the largest section of the report and it is printed first, because a silent refusal is indistinguishable from a clean project.

It also refuses the components that would silently un-fix themselves

A component added by a Blueprint construction script is rebuilt from the Blueprint every time the level loads. Clearing its flag on the placed instance writes a value the next load throws away.

Overlap Warden refuses those by name and points at the Blueprint, where the fix actually belongs — because the worst thing a tool like this can do is not miss an offender. It is to report a flag cleared, have the next editor load quietly restore it, and leave you paying a cost you were told you had stopped paying. A silent revert looks exactly like a success.

It asks the engine which components those are (CreationMethod), rather than matching the NODE_ name prefix they happen to carry — a naming convention is not a fact.

What it will not claim

The safety argument is about behaviour the engine can reach. It is not a claim that nothing anywhere reads the flag as a value — a Blueprint could legally branch on GetGenerateOverlapEvents() and behave differently. On a component that cannot produce overlaps at all that branch is already dead logic, and we consider the case pathological, but it is possible and this tool does not claim to have excluded something it did not measure. That sentence is in the licence too.

Coverage is stated, never implied

The report declares everything the scan could not see, in the same weight as everything it could: World Partition / One File Per Actor maps whose actors are not present when a commandlet opens them, maps that would not load, a scan that ran while the asset registry was still building, and — loudly — a scan that examined no maps at all.

A clean bill that silently excluded half a modern project is a lie by omission, and a CI gate that looks at nothing and reports clean is worse than no gate.

Built for CI, which is why there is no panel

UnrealEditor-Cmd.exe YourProject.uproject -run=OverlapWarden -Budget=0

• 0 — within budget
• 1 — over budget: your level regressed
• 2 — the tool could not do its job: the tool broke
• 3 — bad arguments

0 and 1 are deliberately not "success and failure". Telling your level regressed apart from the tool broke is the difference between two very different mornings.

-Apply re-proves every planned component and writes nothing. -Execute is a second switch, and -Execute without -Apply is refused rather than interpreted — one mistyped switch must not be able to edit a shipped level. After it writes, it re-scans and reports that second independent pass rather than its own count of edits, because a count produced by the code that did the work is a claim, not evidence.

What ships

• Full C++ source, raw and readable. No minification, no obfuscation, no compiled-only blobs.
• A headless commandlet: scan, plan, apply, re-scan.
• A versioned plan.json — the preview you approve, which the apply layer refuses if it was written by a different predicate version than the build about to act on it.
• A standalone single-file HTML proof sheet. No external font, no CDN, no script, and no filesystem path, user name or directory anywhere in it — there is an automation test asserting that.
• 25 automation tests.

Compatibility

Unreal Engine 5.8, Windows. That is the only engine this was built and gate-verified against, and it is the only version claimed. A compatibility claim that outruns a build is not worth reading.

More CSAF tools for Unreal

Project-Wide Level Surgeon — set, swap and tag actors across every map in the project, with a preview and a full undo journal.
Material Sprawl Collapser — merges duplicate materials into one master.
Shadow Thrash Fixer — proves which movable actors never move, then fixes them.