NavMeshAgent requests, pending paths and arrival

Prepared navigation data is part of the feature

An agent needs a compatible navigation surface before a destination request becomes meaningful. The lesson uses AI Navigation 2.0 documentation with Unity6000.0, a NavMeshSurface configured for a known Agent Type and an agent placed on the resulting baked data. Collection layers and geometry determine what was baked, so a visually open floor is not automatically reachable navigation space. Record the installed package version rather than assuming every later version uses identical Inspector defaults. Keep the agent free from an unreviewed competing Rigidbody or Transform writer for this baseline. These are integration prerequisites, not values a pure C# arrival predicate can infer.

Submit a request once, then observe guarded states

RequestPath checks an assigned destination, an enabled agent and isOnNavMesh before calling SetDestination. Its Boolean result means the destination was requested successfully, not that route calculation or travel finished. The component records the request frame and begins observations on a later frame rather than immediately treating stale data as a result. Update checks binding, pending calculation, path status, active path and finite remaining distance in that order. Only a complete active path inside stoppingDistance with sufficiently small velocity is labelled arrived. Publish logs transitions between observation labels instead of producing the same message every frame.

    private void Update()
    {
        if (!submitted || Time.frameCount <= requestFrame) return;
        if (!agent.enabled || !agent.isOnNavMesh) { Publish("not on NavMesh"); return; }
        if (agent.pathPending) { Publish("pending"); return; }
        if (agent.pathStatus != NavMeshPathStatus.PathComplete) { Publish(agent.pathStatus.ToString()); return; }
        if (!agent.hasPath) { Publish("no active path"); return; }
        float distance = agent.remainingDistance;
        if (float.IsInfinity(distance) || float.IsNaN(distance)) { Publish("unknown distance"); return; }
        if (distance > agent.stoppingDistance) { Publish("travelling"); return; }
        Publish(agent.velocity.sqrMagnitude > 0.01f ? "braking" : "arrived");
    }

Read each supplied observation as evidence, not an agent simulation

The first portable observation is pending, so even a zero distance cannot make it arrived. The second is partial and is rejected before distance matters. The third has an infinite remaining distance, which the classifier labels unknown distance rather than treating the value as a useful measurement. A complete active path at distance two is travelling, while one at one tenth with stopping distance two tenths and zero squared speed meets this policy’s arrival condition. These five outcomes verify guard ordering on supplied data. They do not calculate a route, build a NavMesh, avoid an obstacle or prove that an agent could ever produce those observations in a particular scene.

Do not convert missing path evidence into success

An agent already standing at its requested position can legitimately have no active path, and an external ResetPath can also remove one. This observer conservatively reports no active path instead of inferring success from absence. That can under-report a gameplay arrival, but it avoids promoting a cleared or never-created path into proof that the requested destination was reached. A production goal system can add request identity, an explicit destination-distance policy and accepted zero-travel commands. Define that additional contract deliberately. Likewise a partial path ending near its own endpoint is not proof that the original goal was reached, even when its remaining distance becomes small.

Practice: distinguish reachable, partial and initially satisfied goals

Bake a simple floor with one obstacle, request a reachable destination and observe state changes with Auto Braking enabled. Then use an unreachable island in a fresh scene copy and inspect whether the path becomes partial or invalid for that setup. Finally place the destination at the agent’s starting position and record the conservative no-active-path case instead of rewriting it as a failure of the engine. Each experiment should preserve the surface Agent Type, agent placement, destination and baked-data version. A log line without those setup facts cannot establish whether the algorithm, data or current binding caused the result.

• Hint: SetDestination acceptance and PathComplete are separate observations.
• Hint: a destination at the current position requires an explicit zero-travel goal policy if gameplay should count it as success.

Practice: add adversarial observations before changing arrival policy

Supply no active path with zero distance, a complete path with nonzero braking speed, a distance exactly equal to the stopping threshold, and an unknown distance. Predict each classifier result. Then add a separately named AlreadyAtGoal command result that uses an explicitly supplied geometric distance and request identity, without changing what a missing navigation path means. Validate negative thresholds and invalid speed values if the pure function becomes public. This exercise is independent of baking an island scene: it strengthens the decision contract while admitting that only the engine adapter can supply real current path observations and package-dependent navigation data.

• Hint: missing evidence should not accidentally become the most successful state.
• Hint: preserve the distinction between an accepted zero-travel goal and an externally cleared path.

Keep route readiness and gameplay completion separately auditable

A useful navigation receipt names the package version, Agent Type, surface bake, initial binding and destination request, then records the relevant current path observations. The example does not chase a moving target every frame, manage off-mesh traversal or assert universal goal completion. Its conservative arrival label is an application policy built on documented observations. The engine script was checked syntactically and against pinned API references without an installed Unity Editor. Desktop execution established only the supplied classifier outputs. Carry those limits forward when integrating quests, patrols or interaction ranges, where reaching a navigation endpoint and satisfying a gameplay objective can be different events.