What you’re seeing is a very Unreal/PIE thing: you can edit instance variables while the game runs, but if that variable is used inside a heavy loop that runs on a timer/tick, changing it can cause a sudden expensive update (or even math edge cases), which looks like the game “stuck”.
In your screenshot you changed Max Effect Distance while you have three big tile fields updating. That can spike hard because it changes the scale target for every tile, so your next timer tick recomputes + applies transforms for everything.
Here’s how to make it safe and smooth.
Common causes:
When you change MaxEffectDistance, the next UpdateTileScales does:
- loop all tile meshes (maybe thousands)
- loop all influencers (3)
- update scale on each mesh/component
That can hitch hard.
Blueprint is single-threaded on the game thread. If the loop is long, the editor UI can feel frozen.
If it hits 0 (even briefly while typing), you get divide-by-zero or huge values → can cause wild results and heavy updates.
In your Update code, clamp MaxEffectDistance before dividing:
- Make a local
SafeMaxDist = Max(MaxEffectDistance, 1.0)
(use Max (float) node)
Then use SafeMaxDist in:
This prevents “0” from freezing things when you type.
Blueprint nodes:
MaxEffectDistance → Max (float) with 1.0 → use that output for division
In UE, when you type 1000, it goes through 1, 10, 100, 1000.
Each intermediate value triggers a huge recalculation.
- Instead of typing, drag the value with the mouse, or
- Type it, then press Enter, and don’t keep the mouse over the field
But better is a code-side fix:
Set UpdateInterval temporarily to something like:
This gives you time to type without triggering 20 updates per second.
This is the biggest “simple win”.
Add:
Set it to true when:
- influencers moved (or you changed a parameter)
Then in UpdateTileScales:
- If
bNeedsUpdate is false → return
For tuning parameters, you can set bNeedsUpdate when a value changes, but Blueprints don’t have automatic property-change callbacks in runtime, so the practical version is:
- Add a key input (like
U) to toggle updates on/off while tuning.
Super simple:
bEnableUpdates bool
- At top of UpdateTileScales: if false → return
So you can pause updates, change values, then unpause.
If you have many tiles, update them in batches:
Add:
CurrentTileIndex int
TilesPerTick int (e.g. 200)
Each Update:
- update only indices
[CurrentTileIndex .. CurrentTileIndex+TilesPerTick)
- advance index, wrap around
This prevents big frame hitches and makes live tweaking safe.
This is the most reliable “no hitch” approach if tile count is high.
If you want the shortest path:
- In your Update logic, replace:
BestDist / MaxEffectDistance
with:
BestDist / Max(MaxEffectDistance, 1.0)
- Temporarily set:
- Change MaxEffectDistance again.
That should stop the “stuck” feeling immediately.
You have 3 Tile_BP actors (Tile_BP, Tile_BP2, Tile_BP3) plus the big FBX scene actor.
If each has its own scaler component updating thousands of tiles, you might be multiplying the work.
Make sure each scaler component is only handling the tiles it should.
Roughly how many tile pieces are in one of those fields?
If it’s in the thousands+, I’d strongly recommend the batching (TilesPerTick) approach so you can tweak variables live with no stalls.