Coordinated navigation for multiple entities in real-time strategy environments requires decoupling route computation from individual agent control. Rather than calculating independent paths for every entity, systems typically delegate waypoint generation to a central director. Secondary units then adapt their trajectories using positional matrices, reducing computational overhead while preserving visual cohesion.

Structural Architecture

Effective squad movement relies on three interconnected components:

1. Centralized Destination Routing: A single authoritative source determines the overarching trajectory. All subordinate nodes calculate coordinates relative to this anchor.
2. Dynamic Offset Transformation: Predefined spatial relationships between members are projected onto the current movement vector. This prevents overlap and maintains tactical alignment without manual recalculation.
3. Navigation Mesh Delegation: Physical traversal is handled by native pathfinding utilities. Agents interpolate toward assigned coordinates while navigating around static geometry.

Implementation Strategy

The following pattern spearates state management from physical movement. A controller matrix broadcasts commands, while individual units interpret offsets and execute navigation.

using UnityEngine;

[RequireComponent(typeof(NavMeshAgent))]
public class TacticalUnit : MonoBehaviour
{
    public Vector3 StoredOffset;
    private NavMeshAgent _navCore;
    private float _traversalSpeed;

    public void Setup(float velocityLimit, Vector3 relativeSpacing)
    {
        _navCore = GetComponent<NavMeshAgent>();
        _traversalSpeed = velocityLimit;
        StoredOffset = relativeSpacing;
        _navCore.speed = velocityLimit;
        _navCore.baseOffset = 0.5f;
    }

    public void RequestRelocation(Vector3 globalGoal)
    {
        Vector3 shiftedCoordinates = globalGoal + StoredOffset;
        _navCore.SetDestination(shiftedCoordinates);
    }
}

public class CommandDirector : MonoBehaviour
{
    [SerializeField] private GameObject unitPrototype;
    [SerializeField] private int squadCapacity = 9;
    
    private TacticalUnit[] _unitArray;
    private Vector3 _movementAxis;
    private Vector3 _commandDestination;

    public void OrganizeGroup()
    {
        _unitArray = new TacticalUnit[squadCapacity];
        int horizontalSlots = Mathf.CeilToInt(Mathf.Sqrt(squadCapacity));
        
        for (int idx = 0; idx < squadCapacity; idx++)
        {
            int xSlot = idx % horizontalSlots;
            int zSlot = idx / horizontalSlots;
            
            GameObject clone = Instantiate(unitPrototype, transform);
            clone.transform.localPosition = Vector3.zero;
            
            TacticalUnit unitRef = clone.GetComponent<TacticalUnit>();
            Vector3 initialStagger = Vector3.right * xSlot * 2.0f + Vector3.forward * zSlot * 2.0f;
            unitRef.Setup(4.5f, initialStagger);
            
            _unitArray[idx] = unitRef;
        }
    }

    public void DispatchMoveCommand(Vector3 targetLocation)
    {
        _commandDestination = targetLocation;
        _movementAxis = (_commandDestination - transform.position).normalized;
        UpdateUnitTrajectories();
    }

    private void UpdateUnitTrajectories()
    {
        Vector3 dirForward = _movementAxis;
        Vector3 dirRight = Quaternion.Euler(0, 90, 0) * _movementAxis;

        for (int i = 0; i < _unitArray.Length; i++)
        {
            Vector3 offsetVector = _unitArray[i].StoredOffset;
            Vector3 alignedTarget = _commandDestination + (dirForward * offsetVector.z + dirRight * offsetVector.x);
            _unitArray[i].RequestRelocation(alignedTarget);
        }
    }
}

Runtime behavior depends heavily on how smoothly agents transition between waypoints. When issuing movement orders, directors should validate reachability through NavMesh.IsPathValid before committing to new assignments. Additionally, introducing slight velocity dampening during formation recalculations prevents jitter when the group encounters narrow corridors or abrupt directional changes.