public JumpPointParam(BaseGrid iGrid, GridPos iStartPos, GridPos iEndPos, DiagonalMovement iDiagonalMovement = DiagonalMovement.Always, HeuristicMode iMode = HeuristicMode.EUCLIDEAN)
: base(iGrid, iStartPos, iEndPos, iDiagonalMovement, iMode)
{
openList = new IntervalHeap <Node>();
CurIterationType = IterationType.LOOP;
}
public AStarParam(StaticGrid iGrid, DiagonalMovement iDiagonalMovement)
{
m_searchGrid = iGrid;
DiagonalMovement = iDiagonalMovement;
m_startNode = null;
m_endNode = null;
}
protected ParamBase(BaseGrid grid, DiagonalMovement diagonalMovement, HeuristicMode mode)
{
SetHeuristic(mode);
searchGrid = grid;
DiagonalMovement = diagonalMovement;
startNode = null;
endNode = null;
}
protected ParamBase(BaseGrid iGrid, DiagonalMovement iDiagonalMovement, HeuristicMode iMode)
{
SetHeuristic(iMode);
MsearchGrid = iGrid;
DiagonalMovement = iDiagonalMovement;
MstartNode = null;
MendNode = null;
}
public ParamBase(BaseGrid iGrid, DiagonalMovement iDiagonalMovement, HeuristicMode iMode)
{
SetHeuristic(iMode);
m_searchGrid = iGrid;
DiagonalMovement = iDiagonalMovement;
m_startNode = null;
m_endNode = null;
}
public override IEnumerable <Square> GetAvailableMoves(Board board)
{
var availableMoves = new List <Square>();
var currentSquare = board.FindPiece(this);
var player = Player;
availableMoves = DiagonalMovement.GetDiagonalMoves(currentSquare, board, player);
return(availableMoves);
}
public AStarParam(StaticGrid iGrid, Point iStartPos, Point iEndPos, DiagonalMovement iDiagonalMovement) : this(iGrid, iDiagonalMovement)
{
m_startNode = m_searchGrid.GetNodeAt(iStartPos.X, iStartPos.Y);
m_endNode = m_searchGrid.GetNodeAt(iEndPos.X, iEndPos.Y);
if (m_startNode == null)
{
m_startNode = new Node(iStartPos.X, iStartPos.Y, 0);
}
if (m_endNode == null)
{
m_endNode = new Node(iEndPos.X, iEndPos.Y, 0);
}
}
public ParamBase(BaseGrid iGrid, GridPos iStartPos, GridPos iEndPos, DiagonalMovement iDiagonalMovement, HeuristicMode iMode) : this(iGrid, iDiagonalMovement, iMode)
{
m_startNode = m_searchGrid.GetNodeAt(iStartPos.x, iStartPos.y);
m_endNode = m_searchGrid.GetNodeAt(iEndPos.x, iEndPos.y);
if (m_startNode == null)
{
m_startNode = new Node(iStartPos.x, iStartPos.y, true);
}
if (m_endNode == null)
{
m_endNode = new Node(iEndPos.x, iEndPos.y, true);
}
}
protected ParamBase(BaseGrid iGrid, GridPos iStartPos, GridPos iEndPos, DiagonalMovement iDiagonalMovement, HeuristicMode iMode) : this(iGrid, iDiagonalMovement, iMode)
{
MstartNode = MsearchGrid.GetNodeAt(iStartPos.X, iStartPos.Y);
MendNode = MsearchGrid.GetNodeAt(iEndPos.X, iEndPos.Y);
if (MstartNode == null)
{
MstartNode = new Node(iStartPos.X, iStartPos.Y, true);
}
if (MendNode == null)
{
MendNode = new Node(iEndPos.X, iEndPos.Y, true);
}
}
public List<GridPos> findPath(BaseGrid grid, DiagonalMovement move, GridPos startPos, GridPos endPos){
JumpPointParam jpParam = new JumpPointParam(
grid,
startPos,
endPos,
true,
move,
HeuristicMode.EUCLIDEAN
);
List<GridPos> result = JumpPointFinder.FindPath(jpParam);
if (debug) Console.WriteLine("found path");
return result;
}
public IMap DefineMap(DiagonalMovement diagonal, int width, int height, int seed, int minPathLength)
{
var IsAGoodMap = false;
IMap ret = null;
var aStar = FinderFactory.GetAStarImplementation();
IHeuristic heuristic;
heuristic = diagonal == DiagonalMovement.Never ?
HeuristicFactory.GetManhattamImplementation() :
HeuristicFactory.GetOctileImplementation();
while (!IsAGoodMap)
{
var nodes = new List <Node>();
var _map = new Map(diagonal, width, height);
var size = Convert.ToInt32((width * height) * (seed / 100M));
var rand = new Random();
while (size > 0)
{
var p = RandNode(rand, width, height, true);
GridMap.Add(p);
size--;
}
_map.DefineAllNodes(GridMap);
_map.StartNode = RandNode(rand, width, height, false);
_map.EndNode = RandNode(rand, width, height, false);
if (!_map.ValidMap())
{
throw new Exception("Invalid map configuration");
}
if (aStar.Find(_map, heuristic)) // verifica se o mapa possui um caminho
{
var path = _map.GetPath();
if (path.Max(e => e.G) >= minPathLength) // verifica se o caminho sastifaz o tamanho minimo
{
IsAGoodMap = true;
ret = _map;
}
}
GridMap = new List <Node>();
}
ret.Clear();
ret.MapType = MapGeneratorEnum.Random;
return(ret);
}
protected ParamBase(BaseGrid grid, GridPos startPos, GridPos endPos, DiagonalMovement diagonalMovement, HeuristicMode mode) : this(grid, diagonalMovement, mode)
{
startNode = searchGrid.GetNodeAt(startPos.X, startPos.Y);
endNode = searchGrid.GetNodeAt(endPos.X, endPos.Y);
if (startNode == null)
{
startNode = new Node(startPos.X, startPos.Y, true);
}
if (endNode == null)
{
endNode = new Node(endPos.X, endPos.Y, true);
}
}
private void Setup(DiagonalMovement diagonal, int width, int height, int startNodeX, int startNodeY, int endNodeX, int endNodeY)
{
Diagonal = diagonal;
Width = width;
Height = height;
Nodes = new Node[height, width];
DefineAllNodes();
StartNode = Nodes[startNodeY, startNodeX];
EndNode = Nodes[endNodeY, endNodeX];
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
Nodes[j, i].X = i;
Nodes[j, i].Y = j;
Nodes[j, i].Walkable = true;
}
}
}
public List <Node> RouteFinding(DiagonalMovement diagonal)
{
var rand = RandomFactory.Rand;
var listnode = new List <Node>();
var run = true;
var node = new Node(Map.StartNode);
while (run)
{
if (!listnode.Exists(i => i.EqualsAll(node)))
{
listnode.Add(node);
}
var list = Map.GetNeighbors(node, diagonal, false, false);
var ind = rand.Next(0, list.Count);
var newnode = list[ind];
run = newnode != null && !listnode.Exists(i => i.EqualsAll(newnode));
if (newnode != null)
{
node = new Node(newnode, node, newnode.Direction);
}
}
return(listnode);
}
public List <Node> GetNeighbors(Node iNode, DiagonalMovement diagonalMovement)
{
int tX = iNode.x;
int tY = iNode.y;
List <Node> neighbors = new List <Node>();
bool tS0 = false, tD0 = false,
tS1 = false, tD1 = false,
tS2 = false, tD2 = false,
tS3 = false, tD3 = false;
GridPos pos = new GridPos();
if (IsWalkableAt(pos.Set(tX, tY - 1)))
{
neighbors.Add(GetNodeAt(pos));
tS0 = true;
}
if (IsWalkableAt(pos.Set(tX + 1, tY)))
{
neighbors.Add(GetNodeAt(pos));
tS1 = true;
}
if (IsWalkableAt(pos.Set(tX, tY + 1)))
{
neighbors.Add(GetNodeAt(pos));
tS2 = true;
}
if (IsWalkableAt(pos.Set(tX - 1, tY)))
{
neighbors.Add(GetNodeAt(pos));
tS3 = true;
}
switch (diagonalMovement)
{
case DiagonalMovement.Always:
tD0 = true;
tD1 = true;
tD2 = true;
tD3 = true;
break;
case DiagonalMovement.Never:
break;
case DiagonalMovement.IfAtLeastOneWalkable:
tD0 = tS3 || tS0;
tD1 = tS0 || tS1;
tD2 = tS1 || tS2;
tD3 = tS2 || tS3;
break;
case DiagonalMovement.OnlyWhenNoObstacles:
tD0 = tS3 && tS0;
tD1 = tS0 && tS1;
tD2 = tS1 && tS2;
tD3 = tS2 && tS3;
break;
default:
break;
}
if (tD0 && IsWalkableAt(pos.Set(tX - 1, tY - 1)))
{
neighbors.Add(GetNodeAt(pos));
}
if (tD1 && IsWalkableAt(pos.Set(tX + 1, tY - 1)))
{
neighbors.Add(GetNodeAt(pos));
}
if (tD2 && IsWalkableAt(pos.Set(tX + 1, tY + 1)))
{
neighbors.Add(GetNodeAt(pos));
}
if (tD3 && IsWalkableAt(pos.Set(tX - 1, tY + 1)))
{
neighbors.Add(GetNodeAt(pos));
}
return(neighbors);
}
public AStarParam(BaseGrid iGrid, float iweight, DiagonalMovement iDiagonalMovement = DiagonalMovement.Always, HeuristicMode iMode = HeuristicMode.EUCLIDEAN)
: base(iGrid, iDiagonalMovement, iMode)
{
Weight = iweight;
}
public AStarParam(BaseGrid grid, GridPos startPos, GridPos endPos, float weight, DiagonalMovement diagonalMovement = DiagonalMovement.Always, HeuristicMode mode = HeuristicMode.Euclidean) : base(grid, startPos, endPos, diagonalMovement, mode) => Weight = weight;
public AStarParam(BaseGrid iGrid, GridPos iStartPos, GridPos iEndPos, float iweight, DiagonalMovement iDiagonalMovement = DiagonalMovement.Always, HeuristicMode iMode = HeuristicMode.Euclidean)
: base(iGrid,iStartPos,iEndPos, iDiagonalMovement,iMode)
{
Weight = iweight;
}
/*
private class NodeComparer : IComparer<Node>
{
public int Compare(Node x, Node y)
{
var result = (x.heuristicStartToEndLen - y.heuristicStartToEndLen);
if (result < 0) return -1;
else
if (result > 0) return 1;
else
{
return 0;
}
}
}
*/
public static List<GridPos> FindPath(AStarParam iParam)
{
var lo = new object();
//var openList = new IntervalHeap<Node>(new NodeComparer());
var openList = new IntervalHeap<Node>();
Node startNode = iParam.StartNode;
Node endNode = iParam.EndNode;
HeuristicDelegate heuristic = iParam.HeuristicFunc;
BaseGrid grid = iParam.SearchGrid;
DiagonalMovement diagonalMovement = iParam.DiagonalMovement;
float weight = iParam.Weight;
startNode.StartToCurNodeLen = 0;
startNode.HeuristicStartToEndLen = 0;
openList.Add(startNode);
startNode.IsOpened = true;
while (openList.Count != 0)
{
Node node = openList.DeleteMin();
node.IsClosed = true;
if (node == endNode)
{
return Node.Backtrace(endNode);
}
List<Node> neighbors = grid.GetNeighbors(node, diagonalMovement);
#if (UNITY)
foreach(var neighbor in neighbors)
#else
Parallel.ForEach(neighbors, neighbor =>
#endif
{
#if (UNITY)
if (neighbor.isClosed) continue;
#else
if (neighbor.IsClosed) return;
#endif
int x = neighbor.X;
int y = neighbor.Y;
float ng = node.StartToCurNodeLen + (float)((x - node.X == 0 || y - node.Y == 0) ? 1 : Math.Sqrt(2));
if (!neighbor.IsOpened || ng < neighbor.StartToCurNodeLen)
{
neighbor.StartToCurNodeLen = ng;
if (neighbor.HeuristicCurNodeToEndLen == null) neighbor.HeuristicCurNodeToEndLen = weight * heuristic(Math.Abs(x - endNode.X), Math.Abs(y - endNode.Y));
neighbor.HeuristicStartToEndLen = neighbor.StartToCurNodeLen + neighbor.HeuristicCurNodeToEndLen.Value;
neighbor.Parent = node;
if (!neighbor.IsOpened)
{
lock (lo)
{
openList.Add(neighbor);
}
neighbor.IsOpened = true;
}
else
{
}
}
}
#if (!UNITY)
);
#endif
}
return new List<GridPos>();
}
public JumpPointParam(BaseGrid iGrid, GridPos iStartPos, GridPos iEndPos, EndNodeUnWalkableTreatment iAllowEndNodeUnWalkable = EndNodeUnWalkableTreatment.Allow, DiagonalMovement iDiagonalMovement = DiagonalMovement.Always, HeuristicMode iMode = HeuristicMode.Euclidean)
: base(iGrid, iStartPos, iEndPos, iDiagonalMovement, iMode)
{
CurEndNodeUnWalkableTreatment = iAllowEndNodeUnWalkable;
openList = new IntervalHeap <Node>();
CurIterationType = IterationType.Loop;
}
public IMap DefineMap(DiagonalMovement diagonal, int width, int height, int seed, int minPathLength)
{
return(DefineMap());
}
public IList <Node> GetNeighbors(Node node, DiagonalMovement diag, bool ByRef = true, bool valid = true)
{
Node newnode;
var neighbors = new List <Node>();
var s0 = false;
var d0 = false;
var s1 = false;
var d1 = false;
var s2 = false;
var d2 = false;
var s3 = false;
var d3 = false;
newnode = GetDirectionNode(node, DirectionMovement.Up, ByRef, valid);
if (newnode != null)
{
neighbors.Add(newnode);
s0 = true;
}
newnode = GetDirectionNode(node, DirectionMovement.Down, ByRef, valid);
if (newnode != null)
{
neighbors.Add(newnode);
s2 = true;
}
newnode = GetDirectionNode(node, DirectionMovement.Left, ByRef, valid);
if (newnode != null)
{
neighbors.Add(newnode);
s1 = true;
}
newnode = GetDirectionNode(node, DirectionMovement.Right, ByRef, valid);
if (newnode != null)
{
neighbors.Add(newnode);
s3 = true;
}
if (diag == DiagonalMovement.Never)
{
return(neighbors);
}
switch (diag)
{
case DiagonalMovement.OnlyWhenNoObstacles:
d0 = s3 && s0;
d1 = s0 && s1;
d2 = s1 && s2;
d3 = s2 && s3;
break;
case DiagonalMovement.IfAtMostOneObstacle:
d0 = s3 || s0;
d1 = s0 || s1;
d2 = s1 || s2;
d3 = s2 || s3;
break;
case DiagonalMovement.Always:
d0 = true;
d1 = true;
d2 = true;
d3 = true;
break;
default:
throw new Exception("Incorrect value of diagonalMovement");
}
newnode = GetDirectionNode(node, DirectionMovement.UpRight, ByRef, valid);
if (d0 && newnode != null)
{
neighbors.Add(newnode);
}
newnode = GetDirectionNode(node, DirectionMovement.UpLeft, ByRef, valid);
if (d1 && newnode != null)
{
neighbors.Add(newnode);
}
newnode = GetDirectionNode(node, DirectionMovement.DownLeft, ByRef, valid);
if (d2 && newnode != null)
{
neighbors.Add(newnode);
}
newnode = GetDirectionNode(node, DirectionMovement.DownRight, ByRef, valid);
if (d3 && newnode != null)
{
neighbors.Add(newnode);
}
//if (neighbors.Any(e => e == null || !e.Walkable ))
// throw new Exception("NO!!");
return(neighbors);
}
public Map(DiagonalMovement diagonal, int width, int height, int startNodeX, int startNodeY, int endNodeX, int endNodeY)
{
Setup(diagonal, width, height, startNodeX, startNodeY, endNodeX, endNodeY);
}
public AStarParam(BaseGrid iGrid, float iweight, DiagonalMovement iDiagonalMovement = DiagonalMovement.IfAtLeastOneWalkable, HeuristicMode iMode = HeuristicMode.Euclidean)
: base(iGrid, iDiagonalMovement, iMode)
{
Weight = iweight;
}
public AStar(Grid grid, DiagonalMovement diagonalMovement, HeuristicType heuristictType)
{
this.grid = grid;
this.diagonalMovement = diagonalMovement;
}
public IMap DefineMap(DiagonalMovement diagonal, int width, int height, int seed, int minPathLength)
{
int _GDC(int a, int b) => (b == 0 || a == 0) ? a | b : _GDC(Min(a, b), Max(a, b) % Min(a, b));
var blocksize = Blocksize > 0 ? Blocksize : _GDC(width, height);
var IsAGoodMap = false;
IMap ret = null;
// finder para valida se o mapa é passavel
var aStar = FinderFactory.GetAStarImplementation();
IHeuristic heuristic;
heuristic = diagonal == DiagonalMovement.Never ?
HeuristicFactory.GetManhattamImplementation() :
HeuristicFactory.GetOctileImplementation();
var subgrid = new List <Node>();
while (!IsAGoodMap)
{
var nodes = new List <Node>();
var _map = new Map(diagonal, width, height);
var size = Convert.ToInt32(blocksize * blocksize * (seed / 100M));
var rand = new Random();
while (size > 0)
{
var p = RandNode(rand, blocksize, blocksize, true);
subgrid.Add(p);
size--;
}
for (int i = 0; i < width; i += blocksize)
{
for (int j = 0; j < height; j += blocksize)
{
foreach (var item in subgrid)
{
var x = item.X + i;
var y = item.Y + j;
if (x < width && y < height)
{
var node = new Node(x, y, false);
GridMap.Add(node);
}
}
}
}
_map.DefineAllNodes(GridMap);
_map.StartNode = RandNode(rand, width, height, false);
_map.EndNode = RandNode(rand, width, height, false);
if (!_map.ValidMap())
{
throw new Exception("Invalid map configuration");
}
if (aStar.Find(_map, heuristic)) // verifica se o mapa possui um caminho
{
var path = _map.GetPath();
if (path.Max(e => e.G) >= minPathLength) // verifica se o caminho sastifaz o tamanho minimo
{
IsAGoodMap = true;
_map.Clear();
ret = _map;
}
}
GridMap = new List <Node>();
subgrid = new List <Node>();
}
ret.Clear();
ret.MapType = MapGeneratorEnum.WithPattern;
return(ret);
}
public AStarParam(BaseGrid iGrid, GridPos iStartPos, GridPos iEndPos, float iweight, DiagonalMovement iDiagonalMovement = DiagonalMovement.IfAtLeastOneWalkable, HeuristicMode iMode = HeuristicMode.EUCLIDEAN)
: base(iGrid, iStartPos, iEndPos, iDiagonalMovement, iMode)
{
Weight = iweight;
}
public List <Node> find(Node node, DiagonalMovement diagonalMovement)
{
List <Node> list = new List <Node>();
int x = node.x;
int y = node.y;
bool flag4;
bool flag3;
bool flag2;
bool flag = flag2 = (flag3 = (flag4 = false));
bool flag8;
bool flag7;
bool flag6;
bool flag5 = flag6 = (flag7 = (flag8 = false));
if (this.isWalk(x, y + 1))
{
list.Add(this.getNode(x, y + 1));
flag2 = true;
}
if (this.isWalk(x + 1, y))
{
list.Add(this.getNode(x + 1, y));
flag = true;
}
if (this.isWalk(x, y - 1))
{
list.Add(this.getNode(x, y - 1));
flag3 = true;
}
if (this.isWalk(x - 1, y))
{
list.Add(this.getNode(x - 1, y));
flag4 = true;
}
switch (diagonalMovement)
{
case DiagonalMovement.ALWAYS:
flag5 = (flag6 = (flag7 = (flag8 = true)));
break;
case DiagonalMovement.NEVER:
return(list);
case DiagonalMovement.IFATMOSTONEOBSTACLE:
flag6 = (flag4 | flag2);
flag5 = (flag2 | flag);
flag7 = (flag | flag3);
flag8 = (flag3 | flag4);
break;
case DiagonalMovement.ONLYWHENNOOBSTACLES:
flag6 = (flag4 & flag2);
flag5 = (flag2 & flag);
flag7 = (flag & flag3);
flag8 = (flag3 & flag4);
break;
}
if (flag6 && this.isWalk(x - 1, y + 1))
{
list.Add(this.getNode(x - 1, y + 1));
}
if (flag5 && this.isWalk(x + 1, y + 1))
{
list.Add(this.getNode(x + 1, y + 1));
}
if (flag7 && this.isWalk(x + 1, y - 1))
{
list.Add(this.getNode(x + 1, y - 1));
}
if (flag8 && this.isWalk(x - 1, y - 1))
{
list.Add(this.getNode(x - 1, y - 1));
}
return(list);
}
public JumpPointParam(BaseGrid grid, EndNodeUnWalkableTreatment allowEndNodeUnWalkable = EndNodeUnWalkableTreatment.Allow, DiagonalMovement diagonalMovement = DiagonalMovement.Always, HeuristicMode mode = HeuristicMode.Euclidean)
: base(grid, diagonalMovement, mode)
{
CurEndNodeUnWalkableTreatment = allowEndNodeUnWalkable;
OpenList = new IntervalHeap <Node>();
CurIterationType = IterationType.Loop;
}
public Map(DiagonalMovement diagonal, int width, int height)
{
Setup(diagonal, width, height, 0, 0, width - 1, height - 1);
}
