private void ExpandHex(IDirectedPath path, Hexside hexside) { var here = path.PathStep.Hex; var there = Board[here.Coords.GetNeighbour(hexside)]; if (there != null && !ClosedSet.Contains(there.Coords)) { var cost = StepCost(here, hexside, there); if ((cost > 0) && (path.TotalCost + cost < BestSoFar || !OpenSet.ContainsKey(there.Coords)) ) { var key = path.TotalCost + cost + Heuristic(there.Coords); var newPath = path.AddStep(there, HexsideDirection(hexside), cost); TraceFindPathEnqueue(there.Coords, key, 0); IDirectedPath oldPath; if (!OpenSet.TryGetValue(there.Coords, out oldPath)) { OpenSet.Add(there.Coords, newPath); Queue.Enqueue(key, newPath); } else if (newPath.TotalCost < oldPath.TotalCost) { OpenSet.Remove(there.Coords); OpenSet.Add(there.Coords, newPath); Queue.Enqueue(key, newPath); } SetBestSoFar(newPath, GetPartnerPath(there.Coords)); } } }
private void ExpandHex(IDirectedPath path, Hexside hexside) { var here = path.PathStep.Coords; var there = here.GetNeighbour(hexside); if (!ClosedSet.Contains(there)) { TryStepCost(here, hexside).IfHasValueDo(cost => { if (path.TotalCost + cost < BestSoFar || !OpenSet.ContainsKey(there)) { Heuristic(there).IfHasValueDo(heuristic => { var key = path.TotalCost + cost + heuristic; var newPath = path.AddStep(there, HexsideDirection(hexside), cost); PathfinderExtensions.TraceFindPathEnqueue(there, key, 0); if (!OpenSet.TryGetValue(there, out var oldPath)) { OpenSet.Add(there, newPath); Queue.Enqueue(key, newPath); } else if (newPath.TotalCost < oldPath.TotalCost) { OpenSet.Remove(there); OpenSet.Add(there, newPath); Queue.Enqueue(key, newPath); } SetBestSoFar(newPath, PartnerPath(there)); }); } }); } }
/// <summary>TODO</summary> private static IDirectedPath MergePaths(IDirectedPath targetPath, IDirectedPath sourcePath) { if (sourcePath != null) { while (sourcePath.PathSoFar != null) { var hexside = sourcePath.PathStep.HexsideExit; var cost = sourcePath.TotalCost - (sourcePath = sourcePath.PathSoFar).TotalCost; targetPath = targetPath.AddStep(sourcePath.PathStep.Hex, hexside, cost); } } return(targetPath); }
/// <summary>Returns the result of stacking <paramref name="mergePath"/> onto <paramref name="targetPath"/></summary> public static Maybe <IDirectedPath> MergePaths <THex>(this IDirectedPath targetPath, IDirectedPath mergePath) where THex : class, IHex { if (mergePath != null) { while (mergePath.PathSoFar != null) { var hexside = mergePath.PathStep.HexsideExit; var cost = mergePath.TotalCost - (mergePath = mergePath.PathSoFar).TotalCost; targetPath = targetPath.AddStep(mergePath.PathStep.Hex, hexside, cost); } } return(targetPath.ToMaybe()); }
/// <summary>Returns the result of stacking <paramref name="mergePath"/> onto <paramref name="this"/></summary> public static Maybe <IDirectedPath> MergePaths(this IDirectedPath @this, IDirectedPath mergePath) { if (@this == null || mergePath == null) { return(null); } while (mergePath.PathSoFar != null) { var hexside = mergePath.PathStep.HexsideExit; var cost = mergePath.TotalCost - (mergePath = mergePath.PathSoFar).TotalCost; @this = @this.AddStep(mergePath.PathStep.Coords, hexside, cost); } return(@this.ToMaybe()); }
void ExpandNeighbour(IDirectedPath path, NeighbourHex neighbour) { if (!OpenSet.Contains(neighbour.Hex.Coords)) { var cost = StepCost(neighbour.Hex, neighbour.HexsideExit); if (cost > 0) { var newPath = path.AddStep(neighbour, cost); var key = Estimate(Heuristic, VectorGoal, Source.Coords, neighbour.Hex.Coords, newPath.TotalCost); TraceFindPathEnqueue(neighbour.Hex.Coords, key >> 16, (int)(key & 0xFFFFu)); Queue.Enqueue(key, newPath); } } }
/// <summary>Returns a new instance composed by extending this DirectedPath by one hex.</summary> /// <param name="this"></param> /// <param name="hex"></param> /// <param name="hexsideExit"></param> /// <param name="stepCost"></param> public static IDirectedPath AddStep(this IDirectedPath @this, IHex hex, Hexside hexsideExit, int stepCost) => @this.AddStep(new DirectedPathStepHex(hex, hexsideExit), stepCost);