Creating 2D Routes within Navigation Area with Obstacles

The created navigation sector only provides the area within which routes are calculated. The routes themselves must be created from the code. So, let's create the corresponding C# component for 2D route calculation:

1. Create the components folder in the data directory of your project: right-click in the Asset Browser and select Create Folder.
2. In the created folder, create a new component: right-click and select Create Code → C# Component and specify a name for the component.

   

3. Open the component in IDE to implement pathfinding logic.

1. Declare component parameters:
   • Two parameters that will accept nodes between which a route should be calculated.
   • Route color.
   Source code (C#)

   public class Route2D : Component
   {
   	// a node that will serve as a start point
   	public Node startPoint = null;
   	// a node that will serve as a destination point
   	public Node finishPoint = null;
   
   	// route color 
   	[ParameterColor]
   	public vec4 routeColor = vec4.ZERO;
   
   	// ....
   }

2. Create a route and set the radius and height for the point which will move along the route in the Init() method. Before creation, check if the nodes to be used as the start and finish points are specified.
   Source code (C#)

   // a route
   private PathRoute route = null;
   
   private void Init()
   {
   	// check if the start and destination nodes are correctly specified via the component interface
   	if (startPoint && finishPoint)
   	{
   		// create a new route
   		route = new PathRoute();
   
   		// set a radius and height for the point which will move along the route
   		route.Radius = 0.1f;
   		route.Height = 0.1f;
   	}
   }

3. To enable displaying the calculated route at run time, turn on Visualizer. Additionally, you can output console messages to the application screen. Add the following logic to the Init() function:
   Source code (C#)

   // enable the onscreen console messages to display info on route calculation
   Unigine.Console.Onscreen = true;
   // enable visualization of the calculated route
   Visualizer.Enabled = true;

4. In the Update() function, calculate the route from the start to destination node:
   Source code (C#)

   private void Update()
   {
   	// check if the start and destination nodes are correctly specified via the component interface
   	if (startPoint && finishPoint)
   	{
   		// calculate the path from the start to destination point
   		//  a destination point of the route is reached.
   		route.Create2D(startPoint.WorldPosition, finishPoint.WorldPosition);
   		if (route.IsReached)
   		{
   			// if the destination point is reached, render the root in a specified color
   			route.RenderVisualizer(routeColor);
   		}
   		else
   			Log.Message($"{node.Name} PathRoute not reached yet\n");
   	}
   }

   Notice

   Here the route is recalculated each frame. However, it is not optimal for application performance. Instead, you can calculate the route once per several frames: pass a delay to the Create2D() function as the third argument.
5. Implement the Shutdown() function to disable the visualizer and onscreen console messages:
   Source code (C#)

   private void Shutdown()
   {
   	Unigine.Console.Onscreen = false;
   	Visualizer.Enabled = false;
   }

Here the full code of the component:

using Unigine;

[Component(PropertyGuid = "ec10a5720354c62988b25974f975b6439a92e6c6")]
public class Route2D : Component
{
	public Node startPoint = null;
	public Node finishPoint = null;

	[ParameterColor]
	public vec4 routeColor = vec4.ZERO;

	private PathRoute route = null;

	private void Init()
	{
		if (startPoint && finishPoint)
		{
			route = new PathRoute();

			route.Radius = 0.1f;
			route.Height = 0.1f;

			Unigine.Console.Onscreen = true;
			Visualizer.Enabled = true;
		}
	}

	private void Update()
	{
		if (startPoint && finishPoint)
		{
			route.Create2D(startPoint.WorldPosition, finishPoint.WorldPosition);
			if (route.IsReached)
			{
				// if the destination point is reached, render the root in a specified color
				route.RenderVisualizer(routeColor);
			}
			else
				Log.Message($"{node.Name} PathRoute not reached yet\n");
		}
	}

	private void Shutdown()
	{
		Unigine.Console.Onscreen = false;
		Visualizer.Enabled = false;
	}
}

When the component logic is implemented, you should assign it to a node.

1. In UnigineEditor, select Create → Node → Dummy and place it in the navigation area.
2. Select the dummy node and assign the Route2D.cs component to it in the Parameters window.
3. In the component parameters, specify the start and finish static meshes in the Start Point and Finish Point fields.

   

4. Change the Route Color, if necessary.

1. In the components folder, create the NodeRotator component.
2. Implement rotation logic:
   Source code (C#)

   public class NodeRotator : Component
   {
   	// parameter that sets an angular velocity of the node
   	public vec3 angularVelocity = vec3.ZERO;
   
   	private void Update()
   	{
   		// calculate the delta of rotation
   		vec3 delta = angularVelocity * Game.IFps;
   		// update node rotation
   		node.SetRotation(node.GetRotation() * new quat(delta.x, delta.y, delta.z));
   	}
   }

3. Assign the component to the capsule primitive that should rotate and specify the Angular Velocity:

   

   The obstacle will rotate as well.
4. Group the sphere primitives and assign the component to the parent dummy node. It will make the spheres rotate around this parent node (as in the case of a sphere, rotation around its own axis won't affect the route calculation).

   

1. In the components folder, create the AreaVisualizer component.
2. Implement the logic:
   Source code (C#)

   public class AreaVisualizer : Component
   {
   	private NavigationSector navigationSector = null;
   
   	private void Init()
   	{
   		// get the navigation sector to which the component is assigned
   		navigationSector = node as NavigationSector;
   
   		// enable rendering of the visualizer
   		if (navigationSector)
   			Visualizer.Enabled = true;
   	}
   
   	private void Update()
   	{
   		// display the navigation area gizmo
   		if (navigationSector)
   			navigationSector.RenderVisualizer();
   	}
   
   	private void Shutdown()
   	{
   		// disable rendering of the visualizer
   		Visualizer.Enabled = false;
   	}
   }

3. Assign the component to the navigation sector.

Click Run to run the component logic and check the result.