Skip to content

NavGrid Baker

Add Component → PlayMaker → NavGrid → NavGrid Baker

The NavGrid Baker scans your Tilemaps and bakes them into a NavGrid Asset.

inspector

Use it to turn Tilemap layouts into navigation data:

  • Walkable vs blocked cells
  • Optional per-cell movement costs
  • Optional reachability pruning (remove unreachable areas)

Typically you:

  1. Add NavGridBaker to a GameObject in your Tilemap scene
  2. Assign your Floor and Wall Tilemaps
  3. Optionally assign Tile Cost Profiles and reachability settings
  4. Bake into a NavGrid asset used by NavGrid Agents

Tip

Import the Maze Chase Sample Game to see an example setup.

Tilemap Sources

Walls

Tilemaps that define blocking cells (union).

  • Any tile found on Walls is treated as not walkable
  • Multiple wall Tilemaps are combined (union)
  • Common use: collision/obstacle layers

Floor

Tilemaps that define walkable floor (union). Optional.

  • If Floor is assigned:
    • A cell is walkable if it has any Floor tile AND no Wall tile
  • If Floor is empty or null:
    • “Floor” is implied everywhere there is no Wall tile
    • This is useful if walls are the only thing drawn

You can use multiple Floor Tilemaps (for different visual layers) and the Baker merges them.

Tile Cost Profiles

Profiles to apply in order (later profiles can override via Max/Add/Set in ApplyProfileCosts).

Assign one or more NavGrid Tile Cost Profiles to decorate the grid with movement costs.

  • Profiles are applied in order
  • Later profiles can override earlier ones (using their internal rules)
  • Costs are only applied on walkable cells

Typical use:

  • One profile for terrain (mud, sand, roads)
  • Another for danger zones (traps, lava, noise)
  • Another for temporary gameplay effects baked into a separate asset

Reachability (Optional)

You can optionally prune unreachable cells so agents only see areas they can actually reach.

Prune cells that are not reachable by flood-fill.

Modes

Reach Source

ReachSource: LargestComponent, FromSeeds

  • Largest Component
  • Finds all connected walkable regions
  • Keeps only the largest region

  • Good for maps where you only care about the “main island”

  • From Seeds

    • Starts from seed cells and keeps only what can be reached
    • Ideal for:
      • Playable areas starting from the player’s spawn
      • Specific chunks (e.g., starting room, safe zone)

Reach Neighbors

Neighbor connectivity for reachability (4-way or 8-way).

  • 4-way - up, down, left, right
  • 8-way - includes diagonals

Reachability uses these rules to decide what counts as “connected”.

Reach Min Clearance

Require at least this clearance when computing reachability (0 = ignore clearance).

  • Uses the NavGrid’s Clearance data if present
  • Cells that don’t meet the minimum clearance are treated as blocked
  • Useful for “fat” agents that can’t go through narrow gaps

Seeds

Used when Reachability = FromSeeds.

Seed Cells

Seed cells used to check for reachability (grid cell coordinates: 0,0 = bottom-left).

  • Explicit list of grid coordinates in NavGrid space
  • Flood-fill starts from these cells
  • Useful when you know exact grid positions you want to keep

Seed Tilemap

Optional Tilemap whose painted cells are seeds.

  • Any tile painted on this Tilemap becomes a seed
  • Good for visually marking starting areas right in the scene
  • Seed coordinates are automatically converted to NavGrid local cells

You can use SeedCells, SeedTilemap, or both.

Target Asset

NavGrid asset to write into (ScriptableObject).

  • The NavGrid ScriptableObject that will receive the baked data
  • The Baker writes:
    • Origin (world-space corner of the grid)
    • AxisU / AxisV (grid orientation & scale)
    • CellSize
    • Size (width × height)
    • Walkable array
    • Cost array
  • If Clearance exists but has the wrong size, it is cleared and left for a separate process to recompute

This lets you:

  • Re-bake the same NavGrid asset from different scenes
  • Share one NavGrid between multiple scenes (if layouts are compatible)

Baking the NavGrid

In the editor:

  1. Add NavGridBaker to a GameObject
  2. Assign:
    • Walls Tilemaps
    • (Optional) Floor Tilemaps
    • (Optional) CostProfiles
    • (Optional) Reachability + Seeds
    • TargetAsset (NavGrid)
  3. Click Bake NavGrid
  4. A Preview shows the baked NavGrid.

On bake, the component:

  1. Finds the union of all Floor/Walls Tilemaps
  2. Computes walkable cells from Floor/Walls
  3. Applies any Tile Cost Profiles
  4. Optionally prunes unreachable cells
  5. Writes the result to the NavGrid asset and saves it

Tips

  • Use separate Tilemaps for Walls and Floor to keep the bake logic clear
  • Combine Tile Cost Profiles to layer different cost sources without touching Tilemaps
  • Use FromSeeds reachability when only part of the map is intended to be playable
  • Re-bake whenever:
    • Level layout changes
    • You change Tiles / Tilemap structure
    • You tweak Tile Cost Profiles