/// <summary>
/// Sprawdzone zostaje czy sąsiadujące komórki nie są na liście zablokowanych i czy nie
/// wykraczają poza siatkę
/// </summary>
/// <returns></returns>
public List <TravelStep> GetAvailableTravelSteps(TravelStep travelStep, bool includeDiagonal)
{
var availableSteps = new List <TravelStep>();
//Południe
if (_warehouseLayout.IsWalkable(new Coord(travelStep.X, travelStep.Y + 1)))
{
availableSteps.Add(new TravelStep(travelStep.X, travelStep.Y + 1));
}
//Zachód
if (_warehouseLayout.IsWalkable(new Coord(travelStep.X + 1, travelStep.Y)))
{
availableSteps.Add(new TravelStep(travelStep.X + 1, travelStep.Y));
}
//Północ
if (_warehouseLayout.IsWalkable(new Coord(travelStep.X, travelStep.Y - 1)))
{
availableSteps.Add(new TravelStep(travelStep.X, travelStep.Y - 1));
}
//Wschód
if (_warehouseLayout.IsWalkable(new Coord(travelStep.X - 1, travelStep.Y)))
{
availableSteps.Add(new TravelStep(travelStep.X - 1, travelStep.Y));
}
if (includeDiagonal)
{
//Północ-Zachód
if (_warehouseLayout.IsWalkable(new Coord(travelStep.X - 1, travelStep.Y - 1)))
{
availableSteps.Add(new TravelStep(travelStep.X - 1, travelStep.Y - 1));
}
//Południe-Wschód
if (_warehouseLayout.IsWalkable(new Coord(travelStep.X + 1, travelStep.Y + 1)))
{
availableSteps.Add(new TravelStep(travelStep.X + 1, travelStep.Y + 1));
}
//Południe-Zachód
if (_warehouseLayout.IsWalkable(new Coord(travelStep.X - 1, travelStep.Y + 1)))
{
availableSteps.Add(new TravelStep(travelStep.X - 1, travelStep.Y + 1));
}
//Północ-Wschód
if (_warehouseLayout.IsWalkable(new Coord(travelStep.X + 1, travelStep.Y - 1)))
{
availableSteps.Add(new TravelStep(travelStep.X + 1, travelStep.Y - 1));
}
}
return(availableSteps);
}
private bool StepIsEmptyAndValid(TravelStep direction, Square currentSquare, Board board)
{
if (direction.TravelFromSquare(currentSquare).IsOnTheBoard())
{
return(board.GetPiece(direction.TravelFromSquare(currentSquare)) == null);
}
return(false);
}
private bool DiagonalStepLandsOnOpposingPieceAndIsValid(TravelStep direction, Square currentSquare, Board board)
{
if (direction.TravelFromSquare(currentSquare).IsOnTheBoard())
{
return(board.GetPiece(direction.TravelFromSquare(currentSquare)) != null &&
board.GetPiece(direction.TravelFromSquare(currentSquare)).Player != this.Player);
}
return(false);
}
public List <Square> GetDiagonalMoves(Square currentSquare, Board board)
{
var diagonalMoves = new List <Square>();
TravelStep upRight = new TravelStep(1, -1);
TravelStep downRight = new TravelStep(1, 1);
TravelStep downLeft = new TravelStep(-1, 1);
TravelStep upLeft = new TravelStep(-1, -1);
diagonalMoves.AddRange(MovesInDirection(currentSquare, upRight, board));
diagonalMoves.AddRange(MovesInDirection(currentSquare, downRight, board));
diagonalMoves.AddRange(MovesInDirection(currentSquare, downLeft, board));
diagonalMoves.AddRange(MovesInDirection(currentSquare, upLeft, board));
return(diagonalMoves);
}
public List <Square> GetLateralMoves(Square currentSquare, Board board)
{
var lateralMoves = new List <Square>();
TravelStep up = new TravelStep(0, -1);
TravelStep down = new TravelStep(0, 1);
TravelStep left = new TravelStep(-1, 0);
TravelStep right = new TravelStep(1, 0);
lateralMoves.AddRange(MovesInDirection(currentSquare, up, board));
lateralMoves.AddRange(MovesInDirection(currentSquare, down, board));
lateralMoves.AddRange(MovesInDirection(currentSquare, left, board));
lateralMoves.AddRange(MovesInDirection(currentSquare, right, board));
return(lateralMoves);
}
public List <Square> GetPawnMoves(Square currentSquare, Board board)
{
int drow = 0;
List <Square> diagonals = new List <Square>();
if (this.Player == Player.White)
{
drow = -1;
}
else if (this.Player == Player.Black)
{
drow = 1;
}
var pawnMoves = new List <Square>();
TravelStep forwards = new TravelStep(0, drow);
TravelStep forwardsTwo = new TravelStep(0, drow + drow);
TravelStep forwardLeft = new TravelStep(-1, drow);
TravelStep forwardRight = new TravelStep(1, drow);
if (StepIsEmptyAndValid(forwards, currentSquare, board))
{
pawnMoves.Add(forwards.TravelFromSquare(currentSquare));
if (!this.HasThisPieceEverMoved && StepIsEmptyAndValid(forwardsTwo, currentSquare, board))
{
pawnMoves.Add(forwardsTwo.TravelFromSquare(currentSquare));
}
}
if (DiagonalStepLandsOnOpposingPieceAndIsValid(forwardLeft, currentSquare, board))
{
pawnMoves.Add(forwardLeft.TravelFromSquare(currentSquare));
}
if (DiagonalStepLandsOnOpposingPieceAndIsValid(forwardRight, currentSquare, board))
{
pawnMoves.Add(forwardRight.TravelFromSquare(currentSquare));
}
if (DiagonalStepIsValidEnPassantMove(forwardLeft, currentSquare, board, drow))
{
pawnMoves.Add(forwardLeft.TravelFromSquare(currentSquare));
}
if (DiagonalStepIsValidEnPassantMove(forwardRight, currentSquare, board, drow))
{
pawnMoves.Add(forwardRight.TravelFromSquare(currentSquare));
}
return(pawnMoves);
}
private List <Square> MovesInDirection(Square startingSquare, TravelStep direction, Board board)
{
List <Square> moves = new List <Square>();
bool encounter = false;
Square tempSquare = direction.TravelFromSquare(startingSquare);
for (var steps = 0; tempSquare.IsOnTheBoard() && !encounter; steps++)
{
moves.Add(tempSquare);
if (board.GetPiece(tempSquare) == null)
{
tempSquare = direction.TravelFromSquare(tempSquare);
}
else
{
encounter = true;
}
}
return(moves);
}
private bool DiagonalStepIsValidEnPassantMove(TravelStep direction, Square currentSquare, Board board, int drow)
{
if (direction.TravelFromSquare(currentSquare).IsOnTheBoard())
{
if (board.GetPiece(direction.TravelFromSquare(currentSquare)) == null)
{
TravelStep sideways = new TravelStep(direction.DeltaCol, 0);
if (board.GetPiece(sideways.TravelFromSquare(currentSquare))?.GetType() == typeof(Pawn) &&
board.GetPiece(sideways.TravelFromSquare(currentSquare))?.Player != this.Player)
{
TravelStep originOfOpposingPawn = new TravelStep(direction.DeltaCol, 2 * direction.DeltaRow);
if (board.PreviousMove.From == originOfOpposingPawn.TravelFromSquare(currentSquare) &&
board.PreviousMove.To == sideways.TravelFromSquare(currentSquare))
{
return(true);
}
}
}
}
return(false);
}
public PathFindingResult <TravelStep> FindPath(TravelStep startTravelStep, TravelStep endTravelStep, bool traverse)
{
var result = new PathFindingResult <TravelStep>();
if (!_warehouseLayout.IsWalkable(startTravelStep.Position))
{
return(new PathFindingResult <TravelStep>()
{
Success = false
});
}
if (!_warehouseLayout.IsWalkable(endTravelStep.Position))
{
return(new PathFindingResult <TravelStep>()
{
Success = false
});
}
var openList = new Heap <TravelStep>();
var closedList = new byte[_warehouseLayout.Width + 1, _warehouseLayout.Height + 1];
var addedToOpenList = new int[_warehouseLayout.Width + 1, _warehouseLayout.Height + 1];
var currentPosition = startTravelStep;
openList.Add(new HeapNode <TravelStep>(currentPosition, currentPosition.TraverseCost * currentPosition.EuclidianDistanceTo(endTravelStep)));
var stepCount = 0;
while (openList.HasMore())
{
stepCount++;
currentPosition = openList.TakeHeapHeadPosition();
if (currentPosition == endTravelStep) // sukces
{
break;
}
closedList[currentPosition.X, currentPosition.Y] = 1;
var movementOptions = GetAvailableTravelSteps(currentPosition, traverse);
// dodaj wyszukane do sterty
foreach (var position in movementOptions)
{
result.CheckedCoordinates.Add(position.Position);
if (closedList[position.X, position.Y] == 1)
{
continue;
}
//var tentativeGScore = currentPosition.CostFromStart + currentPosition.EuclidianDistanceTo(position);
var gScore = currentPosition.CostFromStart + position.TraverseCost;
var cost = gScore + currentPosition.CostFromStart * position.ManhattanDistanceTo(endTravelStep);
position.Parent = currentPosition;
position.CostFromStart = gScore;
if (addedToOpenList[position.X, position.Y] == 0)
{
openList.Add(new HeapNode <TravelStep>(position, cost));
addedToOpenList[position.X, position.Y] = (int)gScore;
}
else if (addedToOpenList[position.X, position.Y] > gScore)
{
openList.Reinsert(new HeapNode <TravelStep>(position, cost));
}
}
}
result.Success = currentPosition == endTravelStep;
//Debug.WriteLine("Wykonano krokow: " + stepCount + ". Wynik końcowy: " + (currentPosition == endTravelStep ? "POWODZENIE" : "NIEPOWODZENIE"));
// powrót po śladach
var steps = new List <ITravelStep>();
while (currentPosition != startTravelStep)
{
var nextPosition = currentPosition.Parent;
currentPosition.Parent = null;
steps.Add(currentPosition);
result.PathCoordinates.Add(currentPosition.Position);
currentPosition = nextPosition as TravelStep;
}
steps.Reverse();
result.Steps = steps.ToArray();
return(result);
}
