Detour Crowd AI: Units brake/slow down behind friendlies instead of pathing around? (RTS Style)

Development Programming & Scripting AI
1

Hi everyone,

I am working on an Auto-Battler / RTS style game. I am using ADetourCrowdAIController and UCrowdFollowingComponent.

The Goal:
I want RTS-style movement where units find the shortest path around friendly units without losing momentum. If a unit is blocked by a friend, it should smoothly steer around them to get to the target, maintaining its movement speed.

The Problem:
My units are behaving too passively. When a unit approaches a stationary group of friendly units from behind, it slows down significantly (almost to a crawl) as if it is stuck in a “forcefield” behind them.
Instead of maintaining speed and curving around the group to find the open path, they brake and slide slowly.

My Setup:

  1. AI Controller: Custom C++ class inheriting from ADetourCrowdAIController.

  2. Character Movement: bUseRVOAvoidance is FALSE (Relying entirely on Detour). Max Acceleration is high to keep movement snappy.

  3. NavMesh: Agent Radius is set correctly (slightly smaller than capsule).

Here is my current C++ configuration for the Crowd Component. I have set a high optimization range hoping they would look for paths around the blockers, but they still brake.

AMinionAIController::AMinionAIController(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
UCrowdFollowingComponent* CrowdComp = Cast(GetPathFollowingComponent());

if (CrowdComp)
{
    // I want them to keep distance, so I have some separation
    CrowdComp->SetCrowdSeparationWeight(2.0f);

    // Detection range
    CrowdComp->SetCrowdCollisionQueryRange(150.0f); 
    
    // High value to encourage finding paths "around" obstacles?
    CrowdComp->SetCrowdPathOptimizationRange(1000.0f);
    
    // Using Low quality to reduce jitter
    CrowdComp->SetCrowdAvoidanceQuality(ECrowdAvoidanceQuality::Low);

    // I disabled this hoping it would stop the braking, but the issue persists
    CrowdComp->SetCrowdAnticipateTurns(false); 
}

}

What I have tried:

  • Increasing PathOptimizationRange to encourage the AI to look for side paths.

  • Disabling AnticipateTurns.

  • Adjusting CollisionQueryRange. Lower values stop the braking but cause clipping; higher values make them brake too early.

The Question:
Is there a specific setting in Detour that controls how aggressively the AI “brakes” when it detects a soft obstacle (like another agent)? I want them to prioritize steering around the obstacle rather than slowing down behind it.

here is also a short video that shows it

2

that brake-and-slide is detour’s local avoidance doing what it is told: stationary friendly agents ahead are velocity obstacles, and the running agent resolves the conflict mostly by slowing rather than steering, because its path still leads through the group. with rvo off, detour is the only avoidance layer, so that is where to work:

  1. tune the avoidance context on the crowd following component: collision query range controls how far ahead neighbors are sensed — a large range makes units brake long before reaching the group, so shrink it to roughly 1.5-2 agent radii. disable crowd separation (or drop its weight way down) since friendlies should not repel each other. and turn on optimize visibility / path optimization so the agent re-curves the path around the group instead of walking into it — the braking is partly pathfollowing approaching a blocked corner.
  2. the real rts answer: same-team units should not be local-avoidance obstacles for each other at all — you want pathfinding around clusters, not local dodging. put a nav obstacle component (or dynamic modifier area) on the stationary blob, keep local avoidance for enemies only, and the forcefield disappears entirely because the crowd manager never sees the friendlies as obstacles. you are moving the problem from local steering to the navmesh, which is where formation games want it.
  3. safety net: re-issue the move request when a unit gets heavily deflected, and keep acceptance radius small so units do not decelerate early near the goal.
    combo that ships: separation off + tight collision query range + optimize visibility on + nav obstacles for stationary friendlies. that gets you shortest-path-around behavior without the crawl.