private List <ChessBoardPosition> GetValidMovePositions(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition)
{
var validPositions = new List <ChessBoardPosition>();
ChessBoardPosition upLeftPosition = chessBoard.CalculatePosition(currentPosition, 2, 1);
ChessBoardPosition upRightPosition = chessBoard.CalculatePosition(currentPosition, 2, -1);
ChessBoardPosition downLeftPosition = chessBoard.CalculatePosition(currentPosition, -2, 1);
ChessBoardPosition downRightPosition = chessBoard.CalculatePosition(currentPosition, -2, -1);
ChessBoardPosition leftUpPosition = chessBoard.CalculatePosition(currentPosition, 1, 2);
ChessBoardPosition leftDownPosition = chessBoard.CalculatePosition(currentPosition, -1, 2);
ChessBoardPosition rightUpPosition = chessBoard.CalculatePosition(currentPosition, 1, -2);
ChessBoardPosition rightDownPosition = chessBoard.CalculatePosition(currentPosition, -1, -2);
validPositions.Add(upLeftPosition);
validPositions.Add(upRightPosition);
validPositions.Add(downLeftPosition);
validPositions.Add(downRightPosition);
validPositions.Add(leftUpPosition);
validPositions.Add(leftDownPosition);
validPositions.Add(rightUpPosition);
validPositions.Add(rightDownPosition);
return(validPositions);
}
public override void Attack(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition, ChessBoardPosition targetPosition)
{
var validPositions = GetValidAttackPositions(chessBoard, currentPosition);
validPositions.RemoveAll(p => p == null);
if (targetPosition == null)
{
throw new Exception("The specified cell is outside the chess board field.");
}
if (validPositions.Any(p => p.CurrentRow == targetPosition.CurrentRow &&
p.CurrentColumn == targetPosition.CurrentColumn))
{
ChessBoardCell cell = chessBoard.GetCell(targetPosition);
if (cell.IsOccupied && cell.Entity != null)
{
cell.Entity.HitPoints = cell.Entity.HitPoints - AttackPower;
Console.WriteLine($"Hit on enemy {cell.Entity.Name} for {AttackPower} damage!");
if (cell.Entity.HitPoints < 1)
{
Console.WriteLine($"Enemy {cell.Entity.Name} is destroyed!");
chessBoard.EmptyCell(targetPosition);
}
Console.ReadLine();
}
}
else
{
throw new Exception("Invalid attack position. Specified cell is not in the attack range.");
}
}
private List <ChessBoardPosition> GetValidMovePositions(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition)
{
var validPositions = new List <ChessBoardPosition>();
for (int radius = 1; radius < MovementPoint + 1; radius++)
{
ChessBoardPosition upLeftPosition = chessBoard.CalculatePosition(currentPosition, radius, radius);
ChessBoardPosition upRight = chessBoard.CalculatePosition(currentPosition, radius, -radius);
ChessBoardPosition downLeftPosition = chessBoard.CalculatePosition(currentPosition, -radius, radius);
ChessBoardPosition downRightPosition = chessBoard.CalculatePosition(currentPosition, -radius, -radius);
validPositions.Add(upLeftPosition);
validPositions.Add(upRight);
validPositions.Add(downLeftPosition);
validPositions.Add(downRightPosition);
ChessBoardPosition upPosition = chessBoard.CalculatePosition(currentPosition, radius, 0);
ChessBoardPosition downPosition = chessBoard.CalculatePosition(currentPosition, -radius, 0);
ChessBoardPosition leftPosition = chessBoard.CalculatePosition(currentPosition, 0, radius);
ChessBoardPosition rightPosition = chessBoard.CalculatePosition(currentPosition, 0, -radius);
validPositions.Add(upPosition);
validPositions.Add(downPosition);
validPositions.Add(leftPosition);
validPositions.Add(rightPosition);
}
return(validPositions);
}
public override void Move(ChessBoard.ChessBoard chessBoard, ChessBoardPosition oldPosition, ChessBoardPosition newPosition)
{
List <PlayerPiece> playerPieces = chessBoard.GetPlayerPiecesBasedOnControlType(EntityControlType.Human);
var validMoves = new List <KeyValuePair <int, List <Point> > >();
foreach (PlayerPiece playerPiece in playerPieces)
{
bool[,] chessBoardGrid = chessBoard.GetPathfinderGrid();
chessBoardGrid[oldPosition.CurrentRow, oldPosition.CurrentColumn] = true;
chessBoardGrid[playerPiece.CurrentPosition.CurrentRow, playerPiece.CurrentPosition.CurrentColumn] = true;
Point startLocation = new Point(oldPosition.CurrentRow, oldPosition.CurrentColumn);
Point endLocation = new Point(playerPiece.CurrentPosition.CurrentRow, playerPiece.CurrentPosition.CurrentColumn);
SearchParameters sp = new SearchParameters(startLocation, endLocation, chessBoardGrid);
PathFinder pathfinder = new PathFinder(sp);
List <Point> nodes = pathfinder.FindPath();
validMoves.Add(new KeyValuePair <int, List <Point> >(nodes.Count, nodes));
}
var paths = new List <int>();
foreach (KeyValuePair <int, List <Point> > pair in validMoves)
{
paths.Add(pair.Key);
}
paths.Sort();
KeyValuePair <int, List <Point> > nextPosition = new KeyValuePair <int, List <Point> >(0, null);
if (paths.Count > 0)
{
nextPosition = validMoves.Find(m => m.Key == paths[0]);
}
if (paths.Count > 0 && nextPosition.Key != 0)
{
newPosition = new ChessBoardPosition
{
CurrentColumn = nextPosition.Value[0].Y,
CurrentRow = nextPosition.Value[0].X,
};
ChessBoardCell newCell = chessBoard.GetCell(newPosition);
if (newCell.IsOccupied)
{
return;
}
else
{
ChessBoardCell cell = chessBoard.GetCell(oldPosition);
chessBoard.SetCell(newPosition, cell);
chessBoard.EmptyCell(oldPosition);
}
}
}
public void MakeNextMove_BishopChessPiece_PossibleCellPositions(string cellPosition)
{
// Arrange
ChessBoard.ChessBoard chessBoard = new ChessBoard.ChessBoard();
ChessBoard.Bishop bishop = new ChessBoard.Bishop();
// Act
var possibleMoves = chessBoard.MakeNextMove(bishop, cellPosition);
// Assert
Assert.DoesNotContain(cellPosition, possibleMoves);
}
public void MakeNextMove_RookChessPiece_PossibleCellPositions(string cellPosition)
{
// Arrange
ChessBoard.ChessBoard chessBoard = new ChessBoard.ChessBoard();
ChessBoard.Rook rook = new ChessBoard.Rook();
// Act
var possibleMoves = chessBoard.MakeNextMove(rook, cellPosition);
// Assert
Assert.DoesNotContain(cellPosition, possibleMoves);
}
public void MakeNextMove_QueenChessPiece_PossibleCellPositions(string cellPosition)
{
// Arrange
ChessBoard.ChessBoard chessBoard = new ChessBoard.ChessBoard();
ChessBoard.Queen queen = new ChessBoard.Queen();
// Act
var possibleMoves = chessBoard.MakeNextMove(queen, cellPosition);
// Assert
Assert.DoesNotContain(cellPosition, possibleMoves);
}
public void MakeNextMove_KingChessPiece_PossibleCellPositions(string cellPosition)
{
// Arrange
ChessBoard.ChessBoard chessBoard = new ChessBoard.ChessBoard();
ChessBoard.King king = new ChessBoard.King();
// Act
var possibleMoves = chessBoard.MakeNextMove(king, cellPosition);
// Assert
Assert.DoesNotContain(cellPosition, possibleMoves);
}
private List <ChessBoardPosition> GetValidMovePositions(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition)
{
var validPositions = new List <ChessBoardPosition>();
ChessBoardPosition upPosition = chessBoard.CalculatePosition(currentPosition, MovementPoint, 0);
ChessBoardPosition downPosition = chessBoard.CalculatePosition(currentPosition, -MovementPoint, 0);
ChessBoardPosition leftPosition = chessBoard.CalculatePosition(currentPosition, 0, MovementPoint);
ChessBoardPosition rightPosition = chessBoard.CalculatePosition(currentPosition, 0, -MovementPoint);
validPositions.Add(upPosition);
validPositions.Add(downPosition);
validPositions.Add(leftPosition);
validPositions.Add(rightPosition);
return(validPositions);
}
private List <ChessBoardPosition> GetValidAttackPositions(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition)
{
var validPositions = new List <ChessBoardPosition>();
ChessBoardPosition upPosition = chessBoard.CalculatePosition(currentPosition, 1, 0, true);
ChessBoardPosition downPosition = chessBoard.CalculatePosition(currentPosition, -1, 0, true);
ChessBoardPosition leftPosition = chessBoard.CalculatePosition(currentPosition, 0, 1, true);
ChessBoardPosition rightPosition = chessBoard.CalculatePosition(currentPosition, 0, -1, true);
validPositions.Add(upPosition);
validPositions.Add(downPosition);
validPositions.Add(leftPosition);
validPositions.Add(rightPosition);
return(validPositions);
}
public override void Attack(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition, ChessBoardPosition targetPosition)
{
var validAttackPosition = new List <ChessBoardPosition>();
ChessBoardPosition upLeftPosition = chessBoard.CalculatePosition(currentPosition, 1, 1, true);
ChessBoardPosition upRight = chessBoard.CalculatePosition(currentPosition, 1, -1, true);
ChessBoardPosition downLeftPosition = chessBoard.CalculatePosition(currentPosition, -1, 1, true);
ChessBoardPosition downRightPosition = chessBoard.CalculatePosition(currentPosition, -1, -1, true);
ChessBoardPosition upPosition = chessBoard.CalculatePosition(currentPosition, 1, 0, true);
ChessBoardPosition downPosition = chessBoard.CalculatePosition(currentPosition, -1, 0, true);
ChessBoardPosition leftPosition = chessBoard.CalculatePosition(currentPosition, 0, 1, true);
ChessBoardPosition rightPosition = chessBoard.CalculatePosition(currentPosition, 0, -1, true);
validAttackPosition.Add(upLeftPosition);
validAttackPosition.Add(upRight);
validAttackPosition.Add(downLeftPosition);
validAttackPosition.Add(downRightPosition);
validAttackPosition.Add(upPosition);
validAttackPosition.Add(downPosition);
validAttackPosition.Add(leftPosition);
validAttackPosition.Add(rightPosition);
validAttackPosition.RemoveAll(p => p == null);
foreach (ChessBoardPosition position in validAttackPosition)
{
ChessBoardCell target = chessBoard.GetCell(position);
if (target.IsOccupied &&
target.Entity != null &&
target.Entity.ControlType == EntityControlType.Human)
{
target.Entity.HitPoints = target.Entity.HitPoints - AttackPower;
Console.WriteLine($"Hit on enemy {target.Entity.Name} for {AttackPower} damage!");
if (target.Entity.HitPoints < 1)
{
Console.WriteLine($"Enemy {target.Entity.Name} is destroyed!");
chessBoard.EmptyCell(position);
}
Console.ReadLine();
}
}
}
private List <ChessBoardPosition> GetValidAttackPositions(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition)
{
var validPositions = new List <ChessBoardPosition>();
for (int orthogonal = 1; orthogonal < chessBoard.Rows; orthogonal++)
{
ChessBoardPosition upPosition = chessBoard.CalculatePosition(currentPosition, orthogonal, 0, true);
ChessBoardPosition downPosition = chessBoard.CalculatePosition(currentPosition, -orthogonal, 0, true);
ChessBoardPosition leftPosition = chessBoard.CalculatePosition(currentPosition, 0, orthogonal, true);
ChessBoardPosition rightPosition = chessBoard.CalculatePosition(currentPosition, 0, -orthogonal, true);
validPositions.Add(upPosition);
validPositions.Add(downPosition);
validPositions.Add(leftPosition);
validPositions.Add(rightPosition);
}
return(validPositions);
}
private List <ChessBoardPosition> GetValidAttackPositions(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition)
{
var validPositions = new List <ChessBoardPosition>();
for (int diagonalCorner = 1; diagonalCorner < chessBoard.Rows; diagonalCorner++)
{
ChessBoardPosition upLeftPosition = chessBoard.CalculatePosition(currentPosition, diagonalCorner, diagonalCorner, true);
ChessBoardPosition upRight = chessBoard.CalculatePosition(currentPosition, diagonalCorner, -diagonalCorner, true);
ChessBoardPosition downLeftPosition = chessBoard.CalculatePosition(currentPosition, -diagonalCorner, diagonalCorner, true);
ChessBoardPosition downRightPosition = chessBoard.CalculatePosition(currentPosition, -diagonalCorner, -diagonalCorner, true);
validPositions.Add(upLeftPosition);
validPositions.Add(upRight);
validPositions.Add(downLeftPosition);
validPositions.Add(downRightPosition);
}
return(validPositions);
}
public override void Attack(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition, ChessBoardPosition targetPosition)
{
var validPositions = GetValidAttackPositions(chessBoard, currentPosition);
validPositions.RemoveAll(p => p == null);
var validTargets = new List <ChessBoardPosition>();
foreach (ChessBoardPosition validPosition in validPositions)
{
ChessBoardCell cell = chessBoard.GetCell(validPosition);
if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Human)
{
validTargets.Add(validPosition);
}
}
if (validTargets.Count > 0)
{
validTargets.Shuffle();
ChessBoardCell target = chessBoard.GetCell(validTargets[0]);
if (target.IsOccupied && target.Entity != null)
{
target.Entity.HitPoints = target.Entity.HitPoints - AttackPower;
Console.WriteLine($"Hit on enemy {target.Entity.Name} for {AttackPower} damage!");
if (target.Entity.HitPoints < 1)
{
Console.WriteLine($"Enemy {target.Entity.Name} is destroyed!");
chessBoard.EmptyCell(validTargets[0]);
}
Console.ReadLine();
}
}
}
public override void Move(ChessBoard.ChessBoard chessBoard, ChessBoardPosition oldPosition, ChessBoardPosition newPosition)
{
var validPositions = GetValidMovePositions(chessBoard, oldPosition);
validPositions.RemoveAll(p => p == null);
if (newPosition == null)
{
throw new Exception("The specified cell is outside the chess board field.");
}
if (validPositions.Any(p => p.CurrentRow == newPosition.CurrentRow &&
p.CurrentColumn == newPosition.CurrentColumn))
{
ChessBoardCell cell = chessBoard.GetCell(oldPosition);
chessBoard.SetCell(newPosition, cell);
chessBoard.EmptyCell(oldPosition);
}
else
{
throw new Exception("Invalid move. Specified cell is not a valid move.");
}
}
public override void Attack(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition, ChessBoardPosition targetPosition)
{
var validPositions = GetValidAttackPositions(chessBoard, currentPosition);
validPositions.RemoveAll(p => p == null);
foreach (ChessBoardPosition position in validPositions)
{
ChessBoardCell cell = chessBoard.GetCell(position);
if (cell.IsOccupied && cell.Entity != null)
{
cell.Entity.HitPoints = cell.Entity.HitPoints - AttackPower;
Console.WriteLine($"Hit on enemy {cell.Entity.Name} for {AttackPower} damage!");
if (cell.Entity.HitPoints < 1)
{
Console.WriteLine($"Enemy {cell.Entity.Name} is destroyed!");
chessBoard.EmptyCell(position);
}
Console.ReadLine();
}
}
}
public override void Move(ChessBoard.ChessBoard chessBoard, ChessBoardPosition oldPosition, ChessBoardPosition newPosition)
{
if ((oldPosition.CurrentRow + 1) < 8)
{
newPosition = new ChessBoardPosition
{
CurrentColumn = oldPosition.CurrentColumn,
CurrentRow = oldPosition.CurrentRow + 1,
};
ChessBoardCell newCell = chessBoard.GetCell(newPosition);
if (newCell.IsOccupied)
{
return;
}
else
{
ChessBoardCell cell = chessBoard.GetCell(oldPosition);
chessBoard.SetCell(newPosition, cell);
chessBoard.EmptyCell(oldPosition);
}
}
}
public virtual void Attack(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition, ChessBoardPosition targetPosition)
{
throw new NotImplementedException();
}
public virtual void Move(ChessBoard.ChessBoard chessBoard, ChessBoardPosition oldPosition, ChessBoardPosition newPosition)
{
throw new NotImplementedException();
}
public override void Attack(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition, ChessBoardPosition targetPosition)
{
//This unit does not attack.
}
public override void Move(ChessBoard.ChessBoard chessBoard, ChessBoardPosition oldPosition, ChessBoardPosition newPosition)
{
List <PlayerPiece> playerPieces = chessBoard.GetPlayerPiecesBasedOnControlType(EntityControlType.Human);
CommandUnitMoveState moveState = CommandUnitMoveState.StayStill;
var possibleAttacks = new List <KeyValuePair <int, List <Point> > >();
foreach (PlayerPiece playerPiece in playerPieces)
{
bool[,] chessBoardGrid = chessBoard.GetPathfinderGrid();
chessBoardGrid[oldPosition.CurrentRow, oldPosition.CurrentColumn] = true;
chessBoardGrid[playerPiece.CurrentPosition.CurrentRow, playerPiece.CurrentPosition.CurrentColumn] = true;
Point startLocation = new Point(oldPosition.CurrentRow, oldPosition.CurrentColumn);
Point endLocation = new Point(playerPiece.CurrentPosition.CurrentRow, playerPiece.CurrentPosition.CurrentColumn);
SearchParameters sp = new SearchParameters(startLocation, endLocation, chessBoardGrid);
PathFinder pathfinder = new PathFinder(sp);
List <Point> nodes = pathfinder.FindPath();
possibleAttacks.Add(new KeyValuePair <int, List <Point> >(nodes.Count, nodes));
}
var paths = new List <int>();
foreach (KeyValuePair <int, List <Point> > pair in possibleAttacks)
{
paths.Add(pair.Key);
}
paths.Sort();
KeyValuePair <int, List <Point> > nearestEnemy = new KeyValuePair <int, List <Point> >(0, null);
if (paths.Count > 0)
{
nearestEnemy = possibleAttacks.Find(m => m.Key == paths[0]);
}
if (paths.Count > 0 && nearestEnemy.Key != 0)
{
if (nearestEnemy.Key == 1 || nearestEnemy.Key == 2)
{
if (nearestEnemy.Value[nearestEnemy.Value.Count - 1].X >= oldPosition.CurrentRow)
{
moveState = CommandUnitMoveState.MoveLeft;
}
else if ((nearestEnemy.Value[nearestEnemy.Value.Count - 1].X <= oldPosition.CurrentRow))
{
moveState = CommandUnitMoveState.MoveRight;
}
}
else
{
bool safeUpLeft = false;
for (int radius = 0; radius < chessBoard.Columns; radius++)
{
ChessBoardPosition upLeftPosition = chessBoard.CalculatePosition(oldPosition, radius, radius, true);
if (upLeftPosition != null)
{
ChessBoardCell cell = chessBoard.GetCell(upLeftPosition);
if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Human)
{
safeUpLeft = false;
}
if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Ai)
{
safeUpLeft = true;
}
}
}
bool safeUpRight = false;
for (int radius = 0; radius < chessBoard.Columns; radius++)
{
ChessBoardPosition upRightPosition = chessBoard.CalculatePosition(oldPosition, radius, -radius, true);
if (upRightPosition != null)
{
ChessBoardCell cell = chessBoard.GetCell(upRightPosition);
if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Human)
{
safeUpRight = false;
}
if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Ai)
{
safeUpRight = true;
}
}
}
bool safeDownLeft = false;
for (int radius = 0; radius < chessBoard.Columns; radius++)
{
ChessBoardPosition downLeftPosition = chessBoard.CalculatePosition(oldPosition, -radius, radius, true);
if (downLeftPosition != null)
{
ChessBoardCell cell = chessBoard.GetCell(downLeftPosition);
if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Human)
{
safeDownLeft = false;
}
if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Ai)
{
safeDownLeft = true;
}
}
}
bool safeDownRight = false;
for (int radius = 0; radius < chessBoard.Columns; radius++)
{
ChessBoardPosition downRightPosition = chessBoard.CalculatePosition(oldPosition, -radius, -radius, true);
if (downRightPosition != null)
{
ChessBoardCell cell = chessBoard.GetCell(downRightPosition);
if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Human)
{
safeDownRight = false;
}
if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Ai)
{
safeDownRight = true;
}
}
}
bool safeUp = false;
for (int radius = 0; radius < chessBoard.Columns; radius++)
{
ChessBoardPosition upPosition = chessBoard.CalculatePosition(oldPosition, radius, 0, true);
if (upPosition != null)
{
ChessBoardCell cell = chessBoard.GetCell(upPosition);
if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Human)
{
safeUp = false;
}
if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Ai)
{
safeUp = true;
}
}
}
bool safeDown = false;
for (int radius = 0; radius < chessBoard.Columns; radius++)
{
ChessBoardPosition downPosition = chessBoard.CalculatePosition(oldPosition, -radius, 0, true);
if (downPosition != null)
{
ChessBoardCell cell = chessBoard.GetCell(downPosition);
if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Human)
{
safeDown = false;
}
if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Ai)
{
safeDown = true;
}
}
}
if (safeUpLeft && safeUpRight && safeDownLeft && safeDownRight)
{
moveState = CommandUnitMoveState.StayStill;
}
if (!safeUpLeft || !safeDownLeft || !safeUp)
{
moveState = CommandUnitMoveState.MoveRight;
}
if (!safeUpRight || !safeDownRight || !safeDown)
{
moveState = CommandUnitMoveState.MoveLeft;
}
}
}
if (moveState == CommandUnitMoveState.MoveLeft)
{
newPosition = new ChessBoardPosition
{
CurrentColumn = oldPosition.CurrentColumn - 1,
CurrentRow = oldPosition.CurrentRow,
};
}
else if (moveState == CommandUnitMoveState.MoveRight)
{
newPosition = new ChessBoardPosition
{
CurrentColumn = oldPosition.CurrentColumn + 1,
CurrentRow = oldPosition.CurrentRow,
};
}
else if (moveState == CommandUnitMoveState.StayStill)
{
return;
}
if (newPosition.CurrentColumn >= 0 && newPosition.CurrentRow >= 0)
{
ChessBoardCell newCell = chessBoard.GetCell(newPosition);
if (newCell.IsOccupied)
{
return;
}
else
{
ChessBoardCell cell = chessBoard.GetCell(oldPosition);
chessBoard.SetCell(newPosition, cell);
chessBoard.EmptyCell(oldPosition);
}
}
}
