Tracer: pathfinding and game AI for .NET

Tracer is a pathfinding and game-AI SDK for real-time simulations with many moving agents: crowds, RTS-style unit groups and tactical squads. It bakes triangle navmeshes, routes single agents and whole swarms across them, reacts to obstacles that appear or vanish mid-game, and adds the game-AI toolkit around pathfinding: line of sight, fog of war, influence maps and combat engagement.

• A swarm costs close to one agent

  Agents that share a goal share one solve, so five hundred agents heading to the same point cost close to one. Adaptive path budgeting keeps large swarms inside a frame-time budget under pressure.

• Obstacles change without a re-bake

  Block and unblock regions of a baked mesh while the game runs. The mesh handle is immutable, so you swap the new one in between ticks.

• Everything around the path

  Line of sight, fog of war, influence maps, congestion analysis, steering behaviors and combat resolution ship in the same SDK, on the same pipeline runtime.

using System.Numerics;
using Tracer;
using Tracer.Models;

var world = new PathfindingWorld();

// A 6x4 room with a wall down the middle and a doorway in it.
// Two triangles per walkable cell; vertices sit on the integer lattice.
var vertices = new List<Vector2>();
var triangles = new List<(int A, int B, int C)>();
var lattice = new Dictionary<(int, int), int>();
int V(int x, int y)
{
    if (!lattice.TryGetValue((x, y), out var i)) { i = vertices.Count; lattice[(x, y)] = i; vertices.Add(new(x, y)); }
    return i;
}
for (int y = 0; y < 4; y++)
    for (int x = 0; x < 6; x++)
    {
        bool wall = x == 3 && y != 1;           // the doorway is the cell (3, 1)
        if (wall) continue;
        triangles.Add((V(x, y), V(x + 1, y), V(x + 1, y + 1)));
        triangles.Add((V(x, y), V(x + 1, y + 1), V(x, y + 1)));
    }

var mesh = await world.CreateNavMeshBakerService().BakeAsync(vertices, triangles);
Console.WriteLine($"triangles: {mesh.TriangleCount}");

// One smoothed path.
var path = await world.CreateSingleAgentService()
    .QueryPathAsync(mesh, new Vector2(0.5f, 3.5f), new Vector2(5.5f, 3.5f));
Console.WriteLine($"single path: {path.Count} waypoints, ends at {path[^1]}");

// A swarm sharing one goal is solved once.
var goal = new Vector2(5.5f, 0.5f);
var agents = Enumerable.Range(1, 3)
    .Select(i => new AgentDto(Id: i, Position: new Vector2(0.5f, i - 0.5f), Goal: goal, GoalChanged: true))
    .ToList();
var tick = await world.CreateMultiAgentService().TickAsync(agents, mesh, tickNumber: 0);
Console.WriteLine($"swarm: {tick.Paths.Count(p => p.PathFound)} of {agents.Count} agents have a path");

// Close the doorway at runtime. No re-bake.
var blocked = await world.CreateDynamicObstacleService()
    .UpdateAsync(mesh, new[] { new NavMeshBlockedZone(Center: new Vector2(3.5f, 1.5f), Radius: 0.6f) });
var after = await world.CreateSingleAgentService("after")
    .QueryPathAsync(blocked, new Vector2(0.5f, 3.5f), new Vector2(5.5f, 3.5f));
Console.WriteLine($"doorway closed: path found = {after.Count > 0}");

triangles: 42
single path: 4 waypoints, ends at <5.5, 3.5>
swarm: 3 of 3 agents have a path
doorway closed: path found = False

This is the complete program, compiled and run against the published package.

• Navmesh baking

  Turn triangle geometry into a queryable navmesh, with obstacle-polygon exclusion and an optional hierarchical bake for large levels, or layered meshes for ground, air and water.

• Single and multi-agent paths

  One-shot smoothed paths, batches in parallel, or a swarm tick where agents with the same goal reuse one solve.

• Dynamic obstacles

  Block and unblock circular zones of a baked mesh at runtime without a full bake.

• Line of sight, fog of war, influence maps

  Visibility and area-control queries for perception and decision-making, with congestion analysis alongside.

• Combat engagement

  Spatially hashed attacker and defender resolution with pluggable damage, dodge and block formulas.

• Steering behaviors

  Seek, Wander, Patrol, Flee, Queue and FlowLane, composed through a fluent navigator builder.

• Grid tactics

  A separate bake-free lane for tile games: line of sight, movement range, cover and target selection over any tilemap.

• Adaptive budgeting and populations

  Cluster large agent counts and path only representatives when the frame budget is tight, or run several named populations under one shared budget.

• The navmesh is made of triangles, not tiles. A tile game bakes two triangles per walkable cell, or uses the bake-free tile lane.
• An unreachable or off-mesh goal never throws. A single query returns an empty list, and a swarm result reports that no path was found.
• Blocking a zone at runtime isolates triangles in place, so the triangle count does not change. Baking with blocked zones excludes them instead.
• Pressure is a meaningful signal only when a frame-time target is set.
• Swarm waypoints are shared guidance. On the level in the diagram they cut doorway corners by up to 0.50 of a cell; single-agent queries stay within 0.11 of a cell. Use single queries where exact corner clearance matters.
• Mesh handles are immutable and safe to read from any thread. Services that persist tuner state should not be driven concurrently under one service key.

Every public type is documented with a worked example in the package readme on NuGet. Open the NuGet page.

Proprietary. Every package ships as a compiled library. Evaluation and non-commercial development or testing are permitted; commercial, production or revenue-generating use needs a commercial licence from the owner. Read the licence terms.