protected abstract void OnPerformAlgorithm(TNode currentNode, TNode neighborNode, TValue neighborPosition, TValue endPosition, StopFunction <TValue> stopFunction);
/// <summary> /// Enumerates the neighbors points for a given node. /// </summary> /// <param name="currentNode">The current node.</param> /// <param name="stopFunction">The stop function.</param> /// <returns></returns> protected abstract IEnumerable <TValue> OnEnumerateNeighbors(TNode currentNode, StopFunction <TValue> stopFunction);
private static bool TryJump(Point sourcePoint, Point targetPoint, Point endPoint, StopFunction stopFunction, out Point jumpPoint)
{
int x = sourcePoint.X;
int y = sourcePoint.Y;
int deltaX = x - targetPoint.X;
int deltaY = y - targetPoint.Y;
jumpPoint = sourcePoint;
if (stopFunction(sourcePoint.X, sourcePoint.Y))
{
return(false);
}
if (sourcePoint == endPoint)
{
return(true);
}
if (deltaX != 0 && deltaY != 0)
{
if (!stopFunction(x - deltaX, y + deltaY) && stopFunction(x - deltaX, y) ||
!stopFunction(x + deltaX, y - deltaY) && stopFunction(x, y - deltaY))
{
return(true);
}
}
else
{
if (deltaX != 0)
{
if ((!stopFunction(x + deltaX, y + 1) && stopFunction(x, y + 1)) ||
!stopFunction(x + deltaX, y - 1) && stopFunction(x, y - 1))
{
return(true);
}
}
else
{
if ((!stopFunction(x + 1, y + deltaY) && stopFunction(x + 1, y)) ||
!stopFunction(x - 1, y + deltaY) && stopFunction(x - 1, y))
{
return(true);
}
}
}
if (deltaX != 0 && deltaY != 0)
{
Point dummyPoint;
bool leftJump = TryJump(new Point(x + deltaX, y), sourcePoint, endPoint, stopFunction, out dummyPoint);
bool bottomJump = TryJump(new Point(x, y + deltaY), sourcePoint, endPoint, stopFunction, out dummyPoint);
if (leftJump || bottomJump)
{
return(true);
}
}
if (!stopFunction(x + deltaX, y) || !stopFunction(x, y + deltaY))
{
return(TryJump(new Point(x + deltaX, y + deltaY), new Point(x, y), endPoint, stopFunction, out jumpPoint));
}
return(false);
}
public void set_train_stop_function(StopFunction train_stop_function)
{
fanndoublePINVOKE.neural_net_set_train_stop_function(swigCPtr, (int)train_stop_function);
}
/// <summary>
/// See <see cref="BaseGraphSearchPathfinder{TNode,TMap}.OnEnumerateNeighbors"/> for more details.
/// </summary>
protected override IEnumerable <WorldmapCluster> OnEnumerateNeighbors(WorldmapNode currentNode, StopFunction <WorldmapCluster> stopFunction)
{
List <WorldmapCluster> result = new List <WorldmapCluster>();
var currentCluster = new Cluster(currentNode.Value.Info);
var currentClusterExits = currentCluster.GetExits();
foreach (var exit in currentClusterExits)
{
if (exit.Kind != akf.Kind.Cluster)
{
continue;
}
var exitCluster = _world.GetCluster(exit.Destination.Internal);
if (exitCluster != null)
{
result.Add(exitCluster);
}
}
return(result);
}
/// <summary>
/// See <see cref="BaseGraphSearchPathfinder{TNode,TMap}.OnEnumerateNeighbors"/> for more details.
/// </summary>
protected override IEnumerable <ClusterDescriptor> OnEnumerateNeighbors(WorldmapNode currentNode, StopFunction <ClusterDescriptor> stopFunction)
{
List <ClusterDescriptor> result = new List <ClusterDescriptor>();
var currentCluster = (ClusterDescriptor)currentNode.Value;
var currentClusterExits = currentCluster.GetExits();
foreach (var exit in currentClusterExits)
{
if (exit.GetKind() != ClusterExitKind.Cluster)
{
continue;
}
ClusterDescriptor cluster = exit.GetDestination();
if (cluster != null)
{
result.Add(cluster);
}
}
return(result);
}
private static DirectionType RotateUntil(Point startPoint, DirectionType direction, StopFunction stopFunction, bool leftSide, bool untilFree)
{
bool condition;
do // rotates until the conditions are fullfilled (determined by untilFree)
{
direction = DirectionHelper.Rotate(direction, leftSide, false);
Point nextLeftPoint = DirectionHelper.GetNextStep(startPoint, direction);
condition = untilFree ? !stopFunction(nextLeftPoint.X, nextLeftPoint.Y) : stopFunction(nextLeftPoint.X, nextLeftPoint.Y);
}while (!condition);
return(direction);
}
public Task <string> StopRequestAsync(StopFunction stopFunction)
{
return(ContractHandler.SendRequestAsync(stopFunction));
}
/// <summary>
/// See <see cref="BasePathfinder.OnTryFindPath"/> for more details.
/// </summary>
protected override bool OnTryFindPath(Point startPoint, Point endPoint,
StopFunction stopFunction,
out IReadOnlyCollection <Point> path,
out IReadOnlyCollection <Point> pivotPoints,
bool optimize = true)
{
// prepares main parameters
bool result = false;
List <Point> pointList = new List <Point>();
// detects all the path segments that are passable
IReadOnlyList <PathSegment> segments = LineRasterizer.ScanPathSegments(startPoint, endPoint, stopFunction);
int segmentIndex = 0;
bool running = true;
while (running)
{
// gets this segment
PathSegment segment = segments[segmentIndex];
Point collisionPoint = segment.LastPoint;
// adds already found points to a final path
pointList.Add(segment.FirstPoint);
pointList.Add(segment.LastPoint);
// we have arrived at destination, we're done here
if (collisionPoint == endPoint)
{
result = true;
break;
}
// cirumvents the obstacle from both sides
EvasionObstacleInfo obstacleInfo;
// tries to circumvent the obstacle from both sides (left/right) to determine which on is shorter
if (TryScanObstacle(collisionPoint, segment.Direction, stopFunction, segments, segmentIndex, out obstacleInfo))
{
// adds better route points to our result structures, advances to the latest segment
segmentIndex += obstacleInfo.SegmentIndex + 1;
// determines left/right side paths step counts
int leftPathStepCount = obstacleInfo.LeftStepCount;
int rightPathStepCount = obstacleInfo.TotalStepCount - leftPathStepCount;
// determines short path
IEnumerable <Point> shorterPath = leftPathStepCount < rightPathStepCount?
obstacleInfo.PivotPoints.Take(obstacleInfo.LefPointCount) :
obstacleInfo.PivotPoints.Skip(obstacleInfo.LefPointCount).Reverse();
// adds this path to overall path
pointList.AddRange(shorterPath);
}
else // path not found
{
running = false;
}
}
// returns the found path
pivotPoints = pointList;
path = pointList;
return(result);
}
private static bool TryScanObstacle(
Point startPoint, // starting point (one before hitting the obstacle)
DirectionType direction, // direction of hitting the obstacle
StopFunction stopFunction,
IEnumerable <PathSegment> segments, // path segments detected from start to end
int segmentIndex, // starting segment in which the obstacle was hit
out EvasionObstacleInfo obstacleInfo) // useful informations about obstacle, and optimal path around
{
// initializes the result structures
bool result = false;
List <Point> cornerPointList = new List <Point>();
obstacleInfo = default(EvasionObstacleInfo);
// detects all the starting points from relevant segments (to be tested for potential evading path end)
IList <Point> finishPoints = segments.
Skip(segmentIndex + 1).
Select(segment => segment.FirstPoint).
ToList();
// initalizes the parameters
int oldSegmentIndex = segmentIndex;
Point position = startPoint;
int totalStepCount = 0;
// expected direction in which start point should be re-entered (this check is essential)
DirectionType entryDirection = RotateUntil(startPoint, direction, stopFunction, false, true);
entryDirection = DirectionHelper.Reverse(entryDirection);
// rotates until the direction is no longer in a collision course (in a given hand side)
direction = RotateUntil(startPoint, direction, stopFunction, true, true);
do
{
// retrieves next point in a actual direction
Point nextPoint = DirectionHelper.GetNextStep(position, direction);
totalStepCount++;
// we've ended up in the start position, that means we can terminate this scan
if (nextPoint == startPoint && direction == entryDirection)
{
break;
}
// detects whether this point coincides with any finish point
int finishPointIndex = finishPoints.IndexOf(nextPoint);
// we've ended up on ther other side, path was found, continue if we can find better finish point (in a higher segment)
if (finishPointIndex >= 0 && finishPointIndex + oldSegmentIndex >= segmentIndex)
{
obstacleInfo = new EvasionObstacleInfo(cornerPointList, totalStepCount, finishPointIndex);
result = true;
}
// rotates (starting at opposite direction) from the wall until it finds a passable spot
DirectionType previousDirection = direction;
direction = RotateUntil(nextPoint, DirectionHelper.Reverse(direction), stopFunction, true, true);
if (direction != previousDirection)
{
cornerPointList.Add(nextPoint);
}
// advances to next point
position = nextPoint;
}while (true);
// returns the points, and operation result
if (result)
{
obstacleInfo.SetTotalStepCount(totalStepCount);
}
return(result);
}
public void set_train_stop_function(StopFunction train_stop_function)
{
fanndoublePINVOKE.neural_net_set_train_stop_function(swigCPtr, (int)train_stop_function);
}
/// <summary>
/// See <see cref="BaseGraphSearchPathfinder{TNode,TMap}.OnPerformAlgorithm"/> for more details.
/// </summary>
protected override void OnPerformAlgorithm(DijkstraNode currentNode, DijkstraNode neighborNode, Vector2 neighborPosition, Vector2 endPosition, StopFunction <Vector2> stopFunction)
{
Int32 neighborScore = currentNode.Score + GetNeighborDistance(currentNode.Value, neighborPosition);
if (neighborNode == null)
{
Map.OpenNode(neighborPosition, currentNode, neighborScore);
}
else if (neighborScore < neighborNode.Score)
{
neighborNode.Update(neighborScore, currentNode);
}
}
/// <summary>
/// See <see cref="BaseGraphSearchPathfinder{TNode,TMap}.OnEnumerateNeighbors"/> for more details.
/// </summary>
protected override IEnumerable <Point> OnEnumerateNeighbors(AStarNode currentNode, StopFunction stopFunction)
{
List <Point> result = new List <Point>();
if (currentNode.Origin != null)
{
int x = currentNode.Point.X;
int y = currentNode.Point.Y;
int px = currentNode.Origin.Point.X;
int py = currentNode.Origin.Point.Y;
// get the normalized direction of travel
int deltaX = (x - px) / Math.Max(Math.Abs(x - px), 1);
int deltaY = (y - py) / Math.Max(Math.Abs(y - py), 1);
// search diagonally
if (deltaX != 0 && deltaY != 0)
{
if (!stopFunction(x, y + deltaY))
{
result.Add(new Point(x, y + deltaY));
}
if (!stopFunction(x + deltaX, y))
{
result.Add(new Point(x + deltaX, y));
}
if (!stopFunction(x, y + deltaY) || !stopFunction(x + deltaX, y))
{
result.Add(new Point(x + deltaX, y + deltaY));
}
if (stopFunction(x - deltaX, y) && !stopFunction(x, y + deltaY))
{
result.Add(new Point(x - deltaX, y + deltaY));
}
if (stopFunction(x, y - deltaY) && !stopFunction(x + deltaX, y))
{
result.Add(new Point(x + deltaX, y - deltaY));
}
}
else // search horizontally/vertically
{
if (deltaX == 0)
{
if (!stopFunction(x, y + deltaY))
{
result.Add(new Point(x, y + deltaY));
if (stopFunction(x + 1, y) && !stopFunction(x + 1, y + deltaY))
{
result.Add(new Point(x + 1, y + deltaY));
}
if (stopFunction(x - 1, y) && !stopFunction(x - 1, y + deltaY))
{
result.Add(new Point(x - 1, y + deltaY));
}
}
}
else
{
if (!stopFunction(x + deltaX, y))
{
result.Add(new Point(x + deltaX, y));
if (stopFunction(x, y + 1) && !stopFunction(x + deltaX, y + 1))
{
result.Add(new Point(x + deltaX, y + 1));
}
if (stopFunction(x, y - 1) && !stopFunction(x + deltaX, y - 1))
{
result.Add(new Point(x + deltaX, y - 1));
}
}
}
}
}
else
{
result.AddRange(base.OnEnumerateNeighbors(currentNode, stopFunction));
}
return(result);
}
/// <summary>
/// See <see cref="IPathfinder.TryFindPath"/> for more details.
/// </summary>
protected virtual Boolean OnTryFindPath(TValue startValue, TValue endValue,
StopFunction <TValue> stopFunction,
out List <TValue> path,
out List <TValue> pivotPoints,
Boolean optimize = true)
{
// prepares main parameters
Boolean result = false;
pivotPoints = null;
path = null;
// clears the map
Map.Clear();
// creates start/finish nodes
TNode endNode = EndNode = Map.CreateEmptyNode(endValue);
// prepares first node
Map.OpenFirstNode(startValue, endValue);
var depth = 0;
while (Map.OpenCount > 0)
{
TNode currentNode = Map.CloseTopNode();
// if current node is obstacle, skip it
if (stopFunction(currentNode.Value))
{
continue;
}
if (depth++ > (600 * 600))
{
return(false);
}
// if we've detected end node, reconstruct the path back to the start
if (currentNode.Equals(endNode))
{
path = ReconstructPath(endValue);
result = true;
break;
}
// processes all the neighbor points
foreach (TValue neighborPoint in OnEnumerateNeighbors(currentNode, stopFunction))
{
// if this neighbor is obstacle skip it, it is not viable node
if (stopFunction(neighborPoint))
{
continue;
}
// determines the node if possible, whether it is closed, and calculates its score
TNode neighborNode = default(TNode);
if (Map.Nodes.TryGetValue(neighborPoint, out neighborNode))
{
Boolean inClosedSet = neighborNode.IsClosed;
// if this node was already processed, skip it
if (inClosedSet)
{
continue;
}
}
// performs the implementation specific variant of graph search algorithm
OnPerformAlgorithm(currentNode, neighborNode, neighborPoint, endValue, stopFunction);
}
}
return(result);
}
/// <summary>
/// See <see cref="BaseGraphSearchPathfinder{TNode,TMap}.OnPerformAlgorithm"/> for more details.
/// </summary>
protected override void OnPerformAlgorithm(SimpleNode currentNode, SimpleNode neighborNode, Point neighborPoint, Point endPoint, StopFunction stopFunction)
{
if (neighborNode == null)
{
Map.OpenNode(neighborPoint, currentNode);
}
}
/// <summary>
/// See <see cref="BaseGraphSearchPathfinder{TNode,TMap}.OnPerformAlgorithm"/> for more details.
/// </summary>
protected override void OnPerformAlgorithm(DijkstraNode currentNode, DijkstraNode neighborNode, Point neighborPoint, Point endPoint, StopFunction stopFunction)
{
int neighborScore = HeuristicHelper.FastEuclideanDistance(neighborPoint, endPoint);
if (neighborNode == null)
{
Map.OpenNode(neighborPoint, currentNode, neighborScore);
}
else if (neighborScore < neighborNode.Score)
{
neighborNode.Update(neighborScore, currentNode);
}
}
/// <summary>
/// Enumerates the neighbors points for a given node.
/// </summary>
/// <param name="currentNode">The current node.</param>
/// <param name="stopFunction">The stop function.</param>
/// <returns></returns>
protected override IEnumerable <Vector2> OnEnumerateNeighbors(TNode currentNode, StopFunction <Vector2> stopFunction)
{
return(Directions.
// creates next step in this direction from current position
Select(direction => DirectionHelper.GetNextStep(currentNode.Value, direction)));
}
public Task <TransactionReceipt> StopRequestAndWaitForReceiptAsync(StopFunction stopFunction, CancellationTokenSource cancellationToken = null)
{
return(ContractHandler.SendRequestAndWaitForReceiptAsync(stopFunction, cancellationToken));
}
/// <summary>
/// See <see cref="BaseGraphSearchPathfinder{TNode,TMap}.OnEnumerateNeighbors"/> for more details.
/// </summary>
protected override IEnumerable <Vector2> OnEnumerateNeighbors(AStarNode currentNode, StopFunction <Vector2> stopFunction)
{
List <Vector2> result = new List <Vector2>();
bool enumerateNeightbors = true;
if (enumerateNeightbors)
{
result.AddRange(base.OnEnumerateNeighbors(currentNode, stopFunction));
}
return(result);
}
/// <summary>
/// See <see cref="BaseGraphSearchPathfinder{TNode,TMap}.OnPerformAlgorithm"/> for more details.
/// </summary>
protected override void OnPerformAlgorithm(AStarNode currentNode, AStarNode neighborNode, Vector2 neighborPosition, Vector2 endPosition, StopFunction <Vector2> stopFunction)
{
Int32 neighborScore = currentNode.Score + GetNeighborDistance(currentNode.Value, neighborPosition);
// opens node at this position
if (neighborNode == null)
{
Map.OpenNode(neighborPosition, currentNode, neighborScore, neighborScore + HeuristicHelper.FastEuclideanDistance(neighborPosition, endPosition));
}
else if (neighborScore < neighborNode.Score)
{
neighborNode.Update(neighborScore, neighborScore + HeuristicHelper.FastEuclideanDistance(neighborPosition, endPosition), currentNode);
}
}
public StopFunction get_train_stop_function()
{
StopFunction ret = (StopFunction)fanndoublePINVOKE.neural_net_get_train_stop_function(swigCPtr);
return(ret);
}
/// <summary>
/// See <see cref="BaseGraphSearchPathfinder{TNode,TMap}.OnPerformAlgorithm"/> for more details.
/// </summary>
protected override void OnPerformAlgorithm(WorldmapNode currentNode, WorldmapNode neighborNode, ClusterDescriptor neighborPosition, ClusterDescriptor endPosition, StopFunction <ClusterDescriptor> stopFunction)
{
Int32 neighborScore = currentNode.Score + GetScore(currentNode.Value, neighborPosition);
// opens node at this position
if (neighborNode == null)
{
Map.OpenNode(neighborPosition, currentNode, neighborScore, neighborScore);
}
else if (neighborScore < neighborNode.Score)
{
neighborNode.Update(neighborScore, neighborScore, currentNode);
}
}
/// <summary>
/// See <see cref="BaseGraphSearchPathfinder{TNode,TMap}.OnPerformAlgorithm"/> for more details.
/// </summary>
protected override void OnPerformAlgorithm(AStarNode currentNode, AStarNode neighborNode, Point neighborPoint, Point endPoint, StopFunction stopFunction)
{
Point jumpPoint;
if (TryJump(neighborPoint, currentNode.Point, endPoint, stopFunction, out jumpPoint))
{
AStarNode jumpNode = Map[jumpPoint.X, jumpPoint.Y];
int distance = HeuristicHelper.FastEuclideanDistance(currentNode.Point, jumpPoint);
int jumpScore = currentNode.Score + distance;
if (jumpNode == null)
{
Map.OpenNode(jumpPoint, currentNode, jumpScore, jumpScore + HeuristicHelper.FastEuclideanDistance(jumpPoint, endPoint));
}
else if (jumpScore < jumpNode.Score)
{
if (jumpNode.IsClosed)
{
return;
}
jumpNode.Update(jumpScore, jumpScore + HeuristicHelper.FastEuclideanDistance(jumpPoint, endPoint), currentNode);
}
}
}
