void ICmpInitializable.OnActivate()
{
_definitionNodeNetwork = GameObj.GetDefinitionNodeNetwork <IDefinitionNodeNetwork>();
_astarAlgorithmVisualization = new AstarAlgorithmVisualization(_definitionNodeNetwork);
_stopwatch = Stopwatch.StartNew();
DualityApp.Mouse.ButtonDown += Mouse_ButtonDown;
}
private static AstarNode[] GenerateNodeNetwork(IDefinitionNodeNetwork definitionNodeNetwork)
{
var nodeNetwork = new AstarNode[definitionNodeNetwork.NodeCount];
for (var i = 0; i < definitionNodeNetwork.NodeCount; i++)
{
nodeNetwork[i] = new AstarNode(definitionNodeNetwork[i]);
}
return(nodeNetwork);
}
private static AstarNode[] GenerateNodeNetwork(IDefinitionNodeNetwork definitionNodeNetwork)
{
var nodeNetwork = new AstarNode[definitionNodeNetwork.NodeCount];
for (var i = 0; i < definitionNodeNetwork.NodeCount; i++)
{
nodeNetwork[i] = new AstarNode {
Parent = -1, Clearance = float.MaxValue
};
}
return(nodeNetwork);
}
public void Draw(IDefinitionNodeNetwork definitionNodeNetwork, Vector2 startPosition, Vector2 targetPosition)
{
var renderer = new MockupRenderer();
var astarAlgorithmVisualization = new AstarAlgorithmVisualization(definitionNodeNetwork);
astarAlgorithmVisualization.SetStart(startPosition);
renderer.ClearCalls();
astarAlgorithmVisualization.Draw(renderer);
Assert.Equal(1, renderer.FillCircleCalls.Count(x => x.color == astarAlgorithmVisualization.StartColor));
Assert.Equal(0, renderer.FillCircleCalls.Count(x => x.color == astarAlgorithmVisualization.TargetColor));
Assert.Equal(0, renderer.FillCircleCalls.Count(x => x.color == astarAlgorithmVisualization.ClosedSetColor || x.color == astarAlgorithmVisualization.OpenSetColor));
astarAlgorithmVisualization.SetTarget(targetPosition);
renderer.ClearCalls();
astarAlgorithmVisualization.Draw(renderer);
Assert.Equal(1, renderer.FillCircleCalls.Count(x => x.color == astarAlgorithmVisualization.StartColor));
Assert.Equal(1, renderer.FillCircleCalls.Count(x => x.color == astarAlgorithmVisualization.TargetColor));
Assert.Equal(0, renderer.FillCircleCalls.Count(x => x.color == astarAlgorithmVisualization.ClosedSetColor || x.color == astarAlgorithmVisualization.OpenSetColor));
astarAlgorithmVisualization.Start(0f, PathfindaxCollisionCategory.None);
while (!astarAlgorithmVisualization.Step())
{
renderer.ClearCalls();
astarAlgorithmVisualization.Draw(renderer);
Assert.True(renderer.FillCircleCalls.Count(x => x.color == astarAlgorithmVisualization.ClosedSetColor || x.color == astarAlgorithmVisualization.OpenSetColor) > 0);
Assert.Equal(1, renderer.FillCircleCalls.Count(x => x.color == astarAlgorithmVisualization.StartColor));
Assert.Equal(1, renderer.FillCircleCalls.Count(x => x.color == astarAlgorithmVisualization.TargetColor));
}
renderer.ClearCalls();
astarAlgorithmVisualization.Draw(renderer);
Assert.True(renderer.FillCircleCalls.Count(x => x.color == astarAlgorithmVisualization.ClosedSetColor || x.color == astarAlgorithmVisualization.OpenSetColor) > 0);
Assert.True(renderer.DrawLineCalls.Count > 0);
Assert.Equal(1, renderer.FillCircleCalls.Count(x => x.color == astarAlgorithmVisualization.StartColor));
Assert.Equal(1, renderer.FillCircleCalls.Count(x => x.color == astarAlgorithmVisualization.TargetColor));
}
private void Draw(IDrawDevice device, IReadOnlyList <ICollisionLayerNode> network, IDefinitionNodeNetwork definitionNodeNetwork)
{
var canvas = new Canvas(device, new CanvasBuffer());
canvas.State.ZOffset = -8;
for (var i = 0; i < network.Count; i++)
{
var node = network[i];
canvas.State.ColorTint = ColorRgba.LightGrey;
var nodeWorldPosition = definitionNodeNetwork.Transformer.ToWorld(node.DefinitionNode.Position);
canvas.FillCircle(nodeWorldPosition.X, nodeWorldPosition.Y, NodeSize);
canvas.State.ColorTint = ColorRgba.VeryLightGrey;
if (node.DefinitionNode.Connections != null)
{
canvas.State.ColorTint = new ColorRgba(199, 21, 133);
foreach (var connection in node.DefinitionNode.Connections)
{
var toNode = NodePointer.Dereference(connection.To, definitionNodeNetwork);
var vector = (definitionNodeNetwork.Transformer.ToWorld(toNode.Position) - nodeWorldPosition) * 0.5f; //Times 0.5f so we can see the connections in both directions.
canvas.DrawDashLine(nodeWorldPosition.X, nodeWorldPosition.Y, nodeWorldPosition.X + vector.X, nodeWorldPosition.Y + vector.Y);
}
if (!float.IsNaN(node.Clearance))
{
canvas.State.ColorTint = ColorRgba.Black;
canvas.DrawText(node.Clearance.ToString(), nodeWorldPosition.X, nodeWorldPosition.Y, -1f, Alignment.Center);
}
}
}
}
public PathRequest <NodePath> CreatePathRequest(IPathfinder <NodePath> pathfinder, IDefinitionNodeNetwork definitionNodes, float x1, float y1, float x2, float y2, PathfindaxCollisionCategory collisionLayer = PathfindaxCollisionCategory.None, byte agentSize = 1)
{
DefinitionNode startNode;
DefinitionNode endNode;
switch (definitionNodes)
{
case IDefinitionNodeGrid definitionNodeGrid:
var offset = -GridClearanceHelper.GridNodeOffset(agentSize, definitionNodeGrid.Transformer.Scale);
startNode = definitionNodeGrid.GetNode(x1 + offset.X, y1 + offset.Y);
endNode = definitionNodeGrid.GetNode(x2 + offset.X, y2 + offset.Y);
return(PathRequest.Create(pathfinder, startNode, endNode, collisionLayer, agentSize));
case IDefinitionNodeNetwork definitionNodeNetwork:
startNode = definitionNodeNetwork.GetNode(x1, y1);
endNode = definitionNodeNetwork.GetNode(x2, y2);
return(PathRequest.Create(pathfinder, startNode, endNode, collisionLayer, agentSize));
default:
throw new NotSupportedException($"{definitionNodes.GetType()} is not supported");
}
}
public static IPathfinder <IDefinitionNodeNetwork, IPathfindNodeNetwork <AstarNode>, WaypointPath> CreateAstarPathfinder(this IPathfindaxManager pathfindaxManager, IDefinitionNodeNetwork nodeNetwork, IDistanceHeuristic _heuristic, int maxClearance = -1, int amountOfThreads = 1)
{
var pathfinder = pathfindaxManager.CreatePathfinder(nodeNetwork, new AStarAlgorithm(nodeNetwork.NodeCount, _heuristic), (definitionNodeNetwork, algorithm, cache) =>
{
var nodeGenerators = new List <IPathfindNodeGenerator <AstarNode> >();
if (definitionNodeNetwork is IDefinitionNodeGrid sourceNodeGrid)
{
nodeGenerators.Add(new BrushfireClearanceGenerator(sourceNodeGrid, maxClearance));
}
var astarNodeNetwork = new AstarNodeNetwork(definitionNodeNetwork, nodeGenerators.ToArray());
return(CreateRequestProcesser(astarNodeNetwork, algorithm, cache));
}, null, amountOfThreads);
pathfinder.Start();
return(pathfinder);
}
/// <summary>
/// Creates a new instance of the <see cref="AstarNodeNetwork"/>
/// </summary>
/// <param name="definitionNodeNetwork"></param>
/// <param name="pathfindNodeGenerators"></param>
public AstarNodeNetwork(IDefinitionNodeNetwork definitionNodeNetwork, params IPathfindNodeGenerator <AstarNode>[] pathfindNodeGenerators)
{
DefinitionNodeNetwork = definitionNodeNetwork;
_pathfindNodeGenerators = pathfindNodeGenerators;
}
public static DefinitionNode Dereference(NodePointer p, IDefinitionNodeNetwork nodeArray)
{
return(nodeArray[p.Index]);
}
