Obstacle avoidance in Unity - Deep Dive

Overview - Obstacle avoidance

What is it?

Obstacle avoidance is a technique used in game development to help characters or objects move around without bumping into things. It makes sure that moving entities detect obstacles in their path and change direction or stop to avoid collisions. This creates smoother and more realistic movement in games. It is especially important for characters controlled by the computer, like enemies or NPCs.

Why it matters

Without obstacle avoidance, game characters would walk straight into walls, objects, or other characters, breaking the game's realism and frustrating players. It solves the problem of navigating complex environments safely and naturally. This improves gameplay experience and makes virtual worlds feel alive and believable.

Where it fits

Before learning obstacle avoidance, you should understand basic Unity concepts like GameObjects, components, and simple movement scripts. After mastering obstacle avoidance, you can explore advanced AI topics like pathfinding, steering behaviors, and navigation meshes to create smarter game agents.

Mental Model

Core Idea

Obstacle avoidance is about sensing nearby objects and adjusting movement to prevent collisions while continuing toward a goal.

Think of it like...

It's like walking through a crowded room: you look around, notice people or furniture in your way, and step aside or slow down to avoid bumping into them.

┌───────────────┐
│   Agent      │
│   (You)      │
└─────┬─────────┘
      │
      ▼
  ┌─────────┐      ┌─────────┐
  │Obstacle │◄─────│ Detection│
  └─────────┘      └─────────┘
      │
      ▼
┌───────────────┐
│ Movement Adjust│
│  (Turn/Stop)  │
└───────────────┘

Build-Up - 6 Steps

1

Foundation

Basic Movement in Unity

Concept: Learn how to move a GameObject using simple scripts.

In Unity, you can move an object by changing its position every frame. For example, using transform.Translate or modifying transform.position inside the Update() method moves the object smoothly. This is the foundation before adding obstacle detection.

Result

The object moves forward continuously in the game scene.

Understanding how to move objects is essential before adding any logic to avoid obstacles.

2

Foundation

Detecting Obstacles with Raycasts

Concept: Use raycasts to sense objects in front of the moving agent.

A raycast shoots an invisible line from a point in a direction and tells you if it hits something. In Unity, Physics.Raycast can detect obstacles ahead. By checking if the ray hits an object within a certain distance, you know when to react.

Result

The script can tell when an obstacle is close in front of the agent.

Raycasts provide a simple and efficient way to detect obstacles before collision happens.

3

Intermediate

Simple Obstacle Avoidance Logic

🤔Before reading on: do you think the agent should stop or turn when an obstacle is detected? Commit to your answer.

Concept: Implement logic to change movement based on obstacle detection.

When the raycast detects an obstacle, the agent can either stop moving forward or turn to avoid it. For example, rotate the agent slightly to the left or right and continue moving. This basic decision-making creates simple avoidance behavior.

Result

The agent stops or turns when it senses an obstacle, preventing collisions.

Knowing how to react to detection is key to making obstacle avoidance feel natural.

4

Intermediate

Using Multiple Raycasts for Better Sensing

🤔Before reading on: do you think one raycast is enough to detect all obstacles around the agent? Commit to your answer.

Concept: Cast several rays in different directions to detect obstacles more reliably.

Instead of one raycast straight ahead, cast multiple rays angled left, center, and right. This helps the agent detect obstacles not only directly in front but also slightly to the sides. It allows smoother turns and better navigation around corners.

Result

The agent senses obstacles in a wider area and avoids them more smoothly.

Expanding sensing coverage reduces blind spots and improves avoidance quality.

5

Advanced

Integrating Steering Behaviors for Smooth Avoidance

🤔Before reading on: do you think abrupt stops or turns look natural in games? Commit to your answer.

Concept: Use steering behaviors to smoothly adjust velocity and direction when avoiding obstacles.

Steering behaviors calculate forces that influence the agent's velocity vector. Instead of stopping or sharply turning, the agent gradually changes direction and speed to flow around obstacles. This creates more lifelike and fluid movement.

Result

The agent moves smoothly around obstacles without sudden jerks or stops.

Applying steering behaviors makes obstacle avoidance visually appealing and realistic.

6

Expert

Combining Obstacle Avoidance with Navigation Meshes

🤔Before reading on: do you think obstacle avoidance alone is enough for complex environments? Commit to your answer.

Concept: Use Unity's NavMesh system alongside obstacle avoidance for pathfinding and dynamic obstacle handling.

NavMesh provides a baked map of walkable areas. Agents use it to find paths around static obstacles. Obstacle avoidance complements this by handling dynamic or unexpected obstacles in real time. Combining both creates robust navigation in complex scenes.

Result

Agents navigate efficiently using paths and avoid collisions with moving or new obstacles.

Understanding how obstacle avoidance fits with pathfinding unlocks advanced AI navigation.

Under the Hood

Obstacle avoidance works by continuously sensing the environment using raycasts or colliders. When an obstacle is detected within a threshold distance, the agent's movement vector is adjusted by changing direction or speed. Steering behaviors calculate smooth changes to velocity, avoiding abrupt movements. In Unity, this involves physics queries and vector math each frame to update the agent's transform.

Why designed this way?

This approach balances performance and realism. Raycasts are cheap and fast for detection, while steering behaviors provide natural movement without complex physics. Alternatives like full physics collision avoidance are costly and less controllable. Combining with NavMesh allows static path planning with dynamic obstacle handling, a practical tradeoff for game AI.

┌───────────────┐
│   Agent Loop  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Raycast Checks│
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Obstacle Hit? │──No──► Continue Forward
└──────┬────────┘
       │Yes
       ▼
┌───────────────┐
│ Calculate New │
│ Direction     │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Apply Steering│
│ Behavior      │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Update Agent  │
│ Position      │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does one raycast straight ahead detect all obstacles around the agent? Commit to yes or no.

Common Belief: One raycast straight ahead is enough to detect all obstacles the agent might hit.

Reality: One raycast only detects obstacles directly in front and misses those slightly to the sides, causing collisions.

Why it matters: Relying on a single raycast leads to blind spots and unexpected crashes in gameplay.

Quick: Should the agent always stop immediately when an obstacle is detected? Commit to yes or no.

Common Belief: The best way to avoid obstacles is to stop moving as soon as one is detected.

Reality: Stopping abruptly looks unnatural and can break game flow; smooth steering is better for realism.

Why it matters: Abrupt stops reduce immersion and can frustrate players expecting fluid movement.

Quick: Is obstacle avoidance alone enough for navigating complex game levels? Commit to yes or no.

Common Belief: Obstacle avoidance by itself can handle all navigation challenges in a game.

Reality: Obstacle avoidance handles local collisions but does not plan paths; pathfinding systems like NavMesh are needed for complex navigation.

Why it matters: Ignoring pathfinding leads to agents getting stuck or wandering inefficiently.

Quick: Does obstacle avoidance always guarantee no collisions? Commit to yes or no.

Common Belief: If obstacle avoidance is implemented, collisions will never happen.

Reality: Obstacle avoidance reduces collisions but cannot guarantee zero collisions, especially with fast-moving or complex obstacles.

Why it matters: Overconfidence can cause bugs and poor player experience if edge cases are not handled.

Expert Zone

1

Obstacle avoidance tuning requires balancing detection distance and reaction speed to avoid jittery or late responses.

2

Combining multiple sensing methods (raycasts, spherecasts, colliders) improves robustness in varied environments.

3

Integrating obstacle avoidance with group behaviors (flocking, crowd simulation) requires careful force blending to prevent conflicts.

When NOT to use

Obstacle avoidance alone is not suitable for large-scale navigation or complex path planning. Instead, use it alongside pathfinding systems like Unity's NavMesh or A* algorithms. For very simple games with static environments, hard-coded paths or triggers may be simpler and more efficient.

Production Patterns

In production, obstacle avoidance is often part of a layered AI system: NavMesh for global pathfinding, steering behaviors for local avoidance, and animation blending for smooth movement. Developers also use debug visualizations of raycasts and avoidance forces to tune behavior. Performance optimization includes limiting raycast frequency and using physics layers to ignore irrelevant objects.

Connections

Pathfinding

Obstacle avoidance builds on pathfinding by handling local dynamic obstacles while pathfinding plans global routes.

Understanding obstacle avoidance clarifies how AI agents navigate complex worlds by combining long-term planning with short-term reactions.

Steering Behaviors

Obstacle avoidance is a specific steering behavior focused on collision prevention.

Knowing steering behaviors helps grasp how multiple movement influences combine to create natural agent motion.

Human Crowd Movement

Obstacle avoidance algorithms mimic how people naturally avoid bumping into others in crowded spaces.

Studying human crowd dynamics informs better AI movement design and vice versa, showing cross-domain parallels.

Common Pitfalls

#1 Agent uses only one raycast straight ahead, missing obstacles on sides.

Wrong approach:

if (Physics.Raycast(transform.position, transform.forward, out hit, 2f)) {
// stop or turn
}

Correct approach:

Vector3[] directions = {transform.forward, Quaternion.Euler(0, 30, 0) * transform.forward, Quaternion.Euler(0, -30, 0) * transform.forward};
foreach (var dir in directions) {
if (Physics.Raycast(transform.position, dir, out hit, 2f)) {
// avoid
break;
}
}

Root cause:

Misunderstanding that one forward raycast covers all possible collision paths.

#2 Agent stops immediately when obstacle detected, causing jerky movement.

Wrong approach:

if (obstacleDetected) {
speed = 0;
} else {
speed = maxSpeed;
}

Correct approach:

if (obstacleDetected) {
Vector3 steeringForce = CalculateAvoidanceForce();
velocity += steeringForce * Time.deltaTime;
} else {
velocity = desiredVelocity;
}

Root cause:

Not applying smooth steering forces and relying on abrupt speed changes.

#3 Relying on obstacle avoidance alone for navigation in complex levels.

Wrong approach:

Agent moves forward with avoidance but no pathfinding, often getting stuck.

Correct approach:

Use NavMeshAgent for pathfinding combined with obstacle avoidance steering behaviors for dynamic obstacles.

Root cause:

Confusing local collision avoidance with global path planning.

Key Takeaways

Obstacle avoidance helps game agents sense and react to nearby obstacles to prevent collisions.

Using multiple raycasts and steering behaviors creates smooth and natural avoidance movement.

Obstacle avoidance complements pathfinding systems but does not replace global navigation planning.

Proper tuning and combining sensing methods improve robustness and realism in agent movement.

Understanding obstacle avoidance is essential for creating believable AI in interactive environments.