public bool CompareMyPositionWithEnemyPosition(Pieces myPiece, Pieces Enemy)
{
if (myPiece.CurrentPosition._PosX == Enemy.CurrentPosition._PosX && myPiece.CurrentPosition._PosY == Enemy.CurrentPosition._PosY && Enemy.PieceColor != myPiece.PieceColor)
{
return(true);
}
return(false);
}
// eftersom ennemy inte har några moves, så får dom de här!
private void SetMovesForEnemiesInList(Pieces piece)
{
foreach (var enemie in TempGameBoard)
{
if (enemie.PieceColor != piece.PieceColor)
{
AiMove.SetMovementList(enemie, TempGameBoard);
}
}
}
/// <summary>
/// The method which is called from the gui to progress the game one turn.
/// </summary>
public void PlayGame()
{
CalculateMovesAndValues();
GiveBestMoveToPieces();
BestPiece = GetBestPiece(GameBoard);
RemoveKilledPiece(BestPiece);
MakeAMove(BestPiece);
logger.LogTurn();
EvaluateStateOfGame();
ClearPieces();
turncounter++;
}
/// <summary>
/// The method for finding out if a tile is occupied by an ally
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="piece"></param>
/// <param name="gameboard"></param>
/// <returns></returns>
private bool EncounterAlly(int x, int y, Pieces piece, List <Pieces> gameboard)
{
foreach (var item in gameboard)
{
if (item.CurrentPosition._PosX == x && item.CurrentPosition._PosY == y)
{
if (item.PieceColor == piece.PieceColor)
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Gets the specific moves that will cancle your state of check
/// </summary>
/// <param name="gameboard"></param>
/// <param name="piece"></param>
private void GetMovesThatCancelChess(List <Pieces> gameboard, Pieces piece)
{
var newlistOfValidMoves = new List <Move>();
for (int i = 0; i < piece.ListOfMoves.Count; i++)
{
if (WillThisMoveCancelChess(gameboard, piece, piece.ListOfMoves[i]))
{
newlistOfValidMoves.Add(piece.ListOfMoves[i]);
}
}
piece.ListOfMoves.Clear();
piece.ListOfMoves = new List <Move>(newlistOfValidMoves);
}
private Pieces GetPieceFromTempBoard(Pieces piece)
{
Pieces tempPiece = null;
for (int i = 0; i < TempGameBoard.Count; i++)
{
if (TempGameBoard[i].CurrentPosition._PosX == piece.CurrentPosition._PosX &&
TempGameBoard[i].CurrentPosition._PosY == piece.CurrentPosition._PosY)
{
tempPiece = TempGameBoard[i];
}
}
return(tempPiece);
}
/// <summary>
/// The method that removes all the moves you can make that will put your own king in check
/// </summary>
/// <param name="piece"></param>
/// <param name="gameboard"></param>
private void RemoveMovesThatWillChessYou(Pieces piece, List <Pieces> gameboard)
{
var savex = piece.CurrentPosition._PosX;
var savey = piece.CurrentPosition._PosY;
var newlistOfValidMoves = new List <Move>();
for (int i = 0; i < piece.ListOfMoves.Count; i++)
{
if (WillItChessYou(piece, piece.ListOfMoves[i], gameboard))
{
newlistOfValidMoves.Add(piece.ListOfMoves[i]);
}
}
piece.ListOfMoves.Clear();
piece.ListOfMoves = new List <Move>(newlistOfValidMoves);
}
// Check if current move is protected by allied piece and returns bool depending on true or false
private bool WillIBeProtected(Move move, Pieces piece)
{
TempGameBoard.Remove(GetPieceFromTempBoard(piece));
if (AmIProtected(move, piece.PieceColor) > 0)
{
RestoreTempGameBoard();
return(true);
}
else
{
RestoreTempGameBoard();
return(false);
}
}
private bool WillIgetThreatened(Move move, Pieces piece)
{
var tempPiece = GetPieceFromTempBoard(piece);
tempPiece.CurrentPosition = new Point(move.endPositions._PosX, move.endPositions._PosY);
if (AmIThreatened(tempPiece))
{
RestoreTempGameBoard();
return(true);
}
else
{
RestoreTempGameBoard();
return(false);
}
}
/// <summary>
/// The public method that sets all the available moves for the piece being sent in
/// </summary>
/// <param name="piece"></param>
/// <param name="gameBoard"></param>
public void SetMovementList(Pieces piece, List <Pieces> gameBoard)
{
//SnapShotOfGameboard = new List<Pieces>(gameBoard);
templist.Clear();
piece.ListOfMoves = new List <Move>(Returnlistofmoves(piece, gameBoard));
bool Chess = AmIInChess(piece.PieceColor, gameBoard);
if (Chess)
{
GetMovesThatCancelChess(gameBoard, piece);
}
else
{
RemoveMovesThatWillChessYou(piece, gameBoard);
}
}
/// <summary>
/// A true or false method if the current move will cancle check or not
/// </summary>
/// <param name="gameboard"></param>
/// <param name="piece"></param>
/// <param name="move"></param>
/// <returns></returns>
private bool WillThisMoveCancelChess(List <Pieces> gameboard, Pieces piece, Move move)
{
var savex = piece.CurrentPosition._PosX;
var savey = piece.CurrentPosition._PosY;
var gameboardtest = new List <Pieces>(gameboard);
Pieces enemypiecesaved = null;
for (int i = 0; i < gameboardtest.Count; i++)
{
if (move.endPositions._PosX == gameboardtest[i].CurrentPosition._PosX && move.endPositions._PosY == gameboardtest[i].CurrentPosition._PosY)
{
enemypiecesaved = gameboardtest[i];
gameboardtest.Remove(gameboardtest[i]);
break;
}
}
for (int i = 0; i < gameboardtest.Count; i++)
{
if (gameboardtest[i].CurrentPosition._PosX == savex && gameboardtest[i].CurrentPosition._PosY == savey)
{
gameboardtest[i].CurrentPosition._PosX = move.endPositions._PosX;
gameboardtest[i].CurrentPosition._PosY = move.endPositions._PosY;
}
}
piece.CurrentPosition._PosX = move.endPositions._PosX;
piece.CurrentPosition._PosY = move.endPositions._PosY;
if (AmIInChess(piece.PieceColor, gameboardtest))
{
piece.CurrentPosition._PosX = savex;
piece.CurrentPosition._PosY = savey;
gameboardtest.Add(enemypiecesaved);
return(false);
}
else
{
piece.CurrentPosition._PosX = savex;
piece.CurrentPosition._PosY = savey;
gameboardtest.Add(enemypiecesaved);
return(true);
}
}
/// <summary>
/// Gives value to move depending on what piece it is going to take next
/// </summary>
/// <param name="move"></param>
private void GiveTakeValue(Move move, Pieces piece)
{
double enemyValue = GetThretnedEnemyPiece(move).Value;
bool protect = false;
var tempenemy = GetThretnedEnemyPiece(move);
foreach (var pmove in tempenemy.ListOfMoves)
{
if (AmIProtected(move, tempenemy.PieceColor) > 0)
{
protect = true;
}
}
move.value += enemyValue;
if (protect)
{
move.value -= piece.Value;
}
}
private bool CanIThreatenTheKing(Move possibleMove, Pieces piece)
{
var testPiece = GetPieceFromTempBoard(piece);
testPiece.CurrentPosition._PosX = possibleMove.endPositions._PosX;
testPiece.CurrentPosition._PosY = possibleMove.endPositions._PosY;
AiMove.SetMovementList(testPiece, TempGameBoard);
foreach (var move in testPiece.ListOfMoves)
{
if (CompareEnemyPositionToMyMove(GetPositionOfEnemyKing(), move))
{
RestoreTempGameBoard();
return(false);
}
}
RestoreTempGameBoard();
return(false);
}
private bool AmIThreatened(Pieces piece)
{
RemovePotentialTakenEnemy(piece);
SetMovesForEnemiesInList(piece);
foreach (var enemy in TempGameBoard)
{
if (enemy.PieceColor != piece.PieceColor)
{
foreach (var move in enemy.ListOfMoves)
{
if (CompareEnemyMoveWithCurrentPosition(move, piece.CurrentPosition))
{
return(true);
}
}
}
}
return(false);
}
/// <summary>
/// Public base method that sets the value to all moves
/// </summary>
/// <param name="piece"></param>
public void GiveValueToMoves(Pieces piece)
{
InitiateAI(piece.PieceColor);
var valuedListOfMoves = new List <Move>();
foreach (Move move in piece.ListOfMoves)
{
var valuedMove = new Move(move.endPositions._PosX, move.endPositions._PosY, 0);
if (CanItakeSomething(move))
{
GiveTakeValue(valuedMove, piece);
}
if (WillIthreaten(piece, move))
{
valuedMove.value += 10;
}
if (WillIgetThreatened(move, piece))
{
RemoveSelfFromValue(valuedMove, piece);
}
if (WillIBeProtected(move, piece))
{
valuedMove.value += piece.Value;
}
//if (CanIThreatenTheKing(move, piece)) /// Doesn't work
//{
// if (!WillIgetThreatened(move, piece) || WillIBeProtected(move, piece))
// valuedMove.value += 25;
//}
GiveRandomValueToAMove(valuedMove);
PawnMoveToPromotion(piece, valuedMove);
valuedListOfMoves.Add(valuedMove);
}
piece.ListOfMoves = valuedListOfMoves;
}
private bool WillIthreaten(Pieces piece, Move move)
{
Pieces tempPiece = GetPieceFromTempBoard(piece);
tempPiece.CurrentPosition = new Point(move.endPositions._PosX, move.endPositions._PosY);
AiMove.SetMovementList(tempPiece, TempGameBoard);
foreach (Move tempMove in tempPiece.ListOfMoves)
{
if (CanItakeSomething(tempMove))
{
RestoreTempGameBoard();
return(true);
}
}
RestoreTempGameBoard();
return(false);
}
/// <summary>
/// The exported specific code for deciding what piece it is and contacting the appropriate methods for finding that specific pieces movelogic
/// </summary>
/// <param name="piece"></param>
/// <param name="gameBoard"></param>
/// <returns></returns>
private List <Move> Returnlistofmoves(Pieces piece, List <Pieces> gameBoard)
{
templist.Clear();
if (piece is Pawn)
{
PawnMovement(piece, gameBoard);
}
else if (piece is Rook)
{
RookMovement(piece, gameBoard);
}
else if (piece is Queen)
{
QueenMovement(piece, gameBoard);
}
else if (piece is King)
{
KingMovement(piece, gameBoard);
}
else if (piece is Horse)
{
HorseMovement(piece, gameBoard);
}
else if (piece is Bishop)
{
BishopMovement(piece, gameBoard);
}
return(templist);
}
/// <summary>
/// Makes the best move this turn.
/// </summary>
/// <param name="piece">The piece which to move.</param>
private void MakeAMove(Pieces piece)
{
if (piece.BestMove != null)
{
piece.CurrentPosition._PosX = piece.BestMove.endPositions._PosX;
piece.CurrentPosition._PosY = piece.BestMove.endPositions._PosY;
if (piece is Pawn)
{
if (piece.PieceColor == Color.Black && piece.BestMove.endPositions._PosY == 0)
{
var QueenFromPawn = new Queen(Color.Black, new Point(piece.CurrentPosition._PosX, piece.CurrentPosition._PosY));
GameBoard.Remove(piece);
GameBoard.Add(QueenFromPawn);
}
else if (piece.BestMove.endPositions._PosY == 7)
{
var QueenFromPawn = new Queen(Color.White, new Point(piece.CurrentPosition._PosX, piece.CurrentPosition._PosY));
GameBoard.Remove(piece);
GameBoard.Add(QueenFromPawn);
}
}
piece.hasBeenMoved = true;
}
}
/// <summary>
/// The specific move logic that concerns Queen
/// </summary>
/// <param name="queen"></param>
/// <param name="gameboard"></param>
private void QueenMovement(Pieces queen, List <Pieces> gameboard)
{
templist.AddRange(AddHorizontalAndVerticalMoves(queen, gameboard));
templist.AddRange(AddDiagonalMove(queen, gameboard));
}
private List <Pieces> GetEnemiesThatIThreaten(Pieces piece)
{
var ListOfThreatnedEnemies = piece.ListOfMoves.Select(move => GetThretnedEnemyPiece(move)).ToList();
return(ListOfThreatnedEnemies);
}
private void RemoveSelfFromValue(Move move, Pieces piece)
{
move.value -= piece.Value;
}
/// <summary>
/// Finds out if one specific move will chess you or not, returns true or false
/// </summary>
/// <param name="piece"></param>
/// <param name="move"></param>
/// <param name="gameboard"></param>
/// <returns></returns>
private bool WillItChessYou(Pieces piece, Move move, List <Pieces> gameboard)
{
bool letssee = WillThisMoveCancelChess(gameboard, piece, move);
return(letssee);
}
/// <summary>
/// The method that adds all available diagonal move positions to the movement list.
/// </summary>
/// <param name="piece"></param>
/// <param name="gameboard"></param>
/// <returns></returns>
private List <Move> AddDiagonalMove(Pieces piece, List <Pieces> gameboard)
{
List <Move> diagonalmoves = new List <Move>();
bool withinbounds = true;
int x = piece.CurrentPosition._PosX;
int y = piece.CurrentPosition._PosY;
do
{
// Looping through spaces up to the right until you run out of gameboard or encounter an enemy or ally
for (int i = 0; i < 6; i++)
{
// Makes sure the initial values are within bounds of the gameboard
if (x <= 7 && y <= 7)
{
// Manipulate the values in the direction we want and check if they are within board
x++;
y++;
if (x <= 7 && y <= 7)
{
// Checks if the newfound tile has an enemy in it
if (EncounterEnemy(x, y, piece, gameboard))
{
diagonalmoves.Add(new Move(x, y, 0));
break;
}
// checks if the newfound tile has an ally in it
else if (EncounterAlly(x, y, piece, gameboard))
{
break;
}
// If the tile is not the original starting position adds the tile ot the movelist
else
{
if (x != piece.CurrentPosition._PosX && y != piece.CurrentPosition._PosY)
{
diagonalmoves.Add(new Move(x, y, 0));
}
}
}
else
{
break;
}
}
}
// adding moves down left
x = piece.CurrentPosition._PosX;
y = piece.CurrentPosition._PosY;
for (int i = 0; i < 6; i++)
{
if (x >= 0 && y >= 0)
{
x--;
y--;
if (x >= 0 && y >= 0)
{
if (EncounterEnemy(x, y, piece, gameboard))
{
diagonalmoves.Add(new Move(x, y, 0));
break;
}
else if (EncounterAlly(x, y, piece, gameboard))
{
break;
}
else
{
if (x != piece.CurrentPosition._PosX && y != piece.CurrentPosition._PosY)
{
diagonalmoves.Add(new Move(x, y, 0));
}
}
}
else
{
break;
}
}
}
x = piece.CurrentPosition._PosX;
y = piece.CurrentPosition._PosY;
// adding moves down to the right
for (int i = 0; i < 6; i++)
{
if (x <= 7 && y >= 0)
{
x++;
y--;
if (x <= 7 && y >= 0)
{
if (EncounterEnemy(x, y, piece, gameboard))
{
diagonalmoves.Add(new Move(x, y, 0));
break;
}
else if (EncounterAlly(x, y, piece, gameboard))
{
break;
}
else
{
if (x != piece.CurrentPosition._PosX && y != piece.CurrentPosition._PosY)
{
diagonalmoves.Add(new Move(x, y, 0));
}
}
}
else
{
break;
}
}
}
x = piece.CurrentPosition._PosX;
y = piece.CurrentPosition._PosY;
// adding moves up to the left
for (int i = 0; i < 6; i++)
{
if (x >= 0 && y <= 7)
{
x--;
y++;
if (x >= 0 && y <= 7)
{
if (EncounterEnemy(x, y, piece, gameboard))
{
diagonalmoves.Add(new Move(x, y, 0));
break;
}
else if (EncounterAlly(x, y, piece, gameboard))
{
break;
}
else
{
if (x != piece.CurrentPosition._PosX && y != piece.CurrentPosition._PosY)
{
diagonalmoves.Add(new Move(x, y, 0));
}
}
}
else
{
break;
}
}
}
withinbounds = false;
} while (withinbounds);
return(diagonalmoves);
}
public void LogPieceToMove(Pieces pieceToMove)
{
var log = string.Format($"{pieceToMove.PieceColor} {pieceToMove.PieceType} from {LetterConversion[pieceToMove.CurrentPosition._PosX]}{pieceToMove.CurrentPosition._PosY + 1} to {LetterConversion[pieceToMove.BestMove.endPositions._PosX]}{pieceToMove.BestMove.endPositions._PosY + 1}");
LogPost += log;
}
public void LogKilledPieceToRemove(Pieces killedPiece)
{
var log = string.Format($" | It took a {killedPiece.PieceColor} {killedPiece.PieceType}");
LogPost += log;
}
/// <summary>
/// The method that adds vertical and horizontal available move positions to the movement list.
/// </summary>
/// <param name="piece"></param>
/// <param name="gameboard"></param>
/// <returns></returns>
private List <Move> AddHorizontalAndVerticalMoves(Pieces piece, List <Pieces> gameboard)
{
List <Move> horizontalAndVerticalMoves = new List <Move>();
bool withinbounds = true;
int x = piece.CurrentPosition._PosX;
int y = piece.CurrentPosition._PosY;
do
{
// This forloop looks for positive changes on the Y axis
for (int i = 0; i < 7; i++)
{
y++;
if (y <= 7)
{
if (EncounterEnemy(x, y, piece, gameboard))
{
horizontalAndVerticalMoves.Add(new Move(x, y, 0));
break;
}
// checks if the newfound tile has an ally in it
else if (EncounterAlly(x, y, piece, gameboard))
{
break;
}
// If the tile is not the original starting position adds the tile ot the movelist
else
{
if (y != piece.CurrentPosition._PosY)
{
horizontalAndVerticalMoves.Add(new Move(x, y, 0));
}
}
}
else
{
break;
}
}
x = piece.CurrentPosition._PosX;
y = piece.CurrentPosition._PosY;
// This forloop looks for negative changes on the Y axis
for (int i = 0; i < 7; i++)
{
y--;
if (y >= 0)
{
if (EncounterEnemy(x, y, piece, gameboard))
{
horizontalAndVerticalMoves.Add(new Move(x, y, 0));
break;
}
// checks if the newfound tile has an ally in it
else if (EncounterAlly(x, y, piece, gameboard))
{
break;
}
// If the tile is not the original starting position adds the tile ot the movelist
else
{
if (y != piece.CurrentPosition._PosY)
{
horizontalAndVerticalMoves.Add(new Move(x, y, 0));
}
}
}
else
{
break;
}
}
x = piece.CurrentPosition._PosX;
y = piece.CurrentPosition._PosY;
// This forloop looks for positive changes on the X axis
for (int i = 0; i < 7; i++)
{
x++;
if (x <= 7)
{
if (EncounterEnemy(x, y, piece, gameboard))
{
horizontalAndVerticalMoves.Add(new Move(x, y, 0));
break;
}
// checks if the newfound tile has an ally in it
else if (EncounterAlly(x, y, piece, gameboard))
{
break;
}
// If the tile is not the original starting position adds the tile ot the movelist
else
{
if (x != piece.CurrentPosition._PosX)
{
horizontalAndVerticalMoves.Add(new Move(x, y, 0));
}
}
}
else
{
break;
}
}
x = piece.CurrentPosition._PosX;
y = piece.CurrentPosition._PosY;
// This forloop looks for positive changes on the X axis
for (int i = 0; i < 7; i++)
{
x--;
if (x >= 0)
{
if (EncounterEnemy(x, y, piece, gameboard))
{
horizontalAndVerticalMoves.Add(new Move(x, y, 0));
break;
}
// checks if the newfound tile has an ally in it
else if (EncounterAlly(x, y, piece, gameboard))
{
break;
}
// If the tile is not the original starting position adds the tile ot the movelist
else
{
if (x != piece.CurrentPosition._PosX)
{
horizontalAndVerticalMoves.Add(new Move(x, y, 0));
}
}
}
else
{
break;
}
}
withinbounds = false;
} while (withinbounds);
return(horizontalAndVerticalMoves);
}
/// <summary>
/// The specific move logic that concerns Bishop
/// </summary>
/// <param name="bishop"></param>
/// <param name="gameboard"></param>
private void BishopMovement(Pieces bishop, List <Pieces> gameboard)
{
templist.AddRange(AddDiagonalMove(bishop, gameboard));
}
/// <summary>
/// The specific move logic that concerns pawn
/// </summary>
/// <param name="pawn"></param>
/// <param name="gameboard"></param>
private void PawnMovement(Pieces pawn, List <Pieces> gameboard)
{
List <Move> pawnMoveList = new List <Move>();
var x = pawn.CurrentPosition._PosX;
var y = pawn.CurrentPosition._PosY;
if (pawn.PieceColor == Color.White)
{
pawnMoveList.Add((new Move((x), (y + 1), 0)));
pawnMoveList.Add((new Move((x + 1), (y + 1), 0)));
pawnMoveList.Add((new Move((x - 1), (y + 1), 0)));
if (pawn.hasBeenMoved == false)
{
pawnMoveList.Add((new Move((x), (y + 2), 0)));
}
}
else if (pawn.PieceColor == Color.Black)
{
pawnMoveList.Add((new Move((x), (y - 1), 0)));
pawnMoveList.Add((new Move((x + 1), (y - 1), 0)));
pawnMoveList.Add((new Move((x - 1), (y - 1), 0)));
if (pawn.hasBeenMoved == false)
{
pawnMoveList.Add((new Move((x), (y - 2), 0)));
}
}
for (int i = 0; i < pawnMoveList.Count; i++)
{
x = pawnMoveList[i].endPositions._PosX;
y = pawnMoveList[i].endPositions._PosY;
if (x <= 7 && x >= 0 && y >= 0 && y <= 7)
{
if (EncounterAlly(x, y, pawn, gameboard))
{
}
else if (EncounterEnemy(x, y, pawn, gameboard))
{
if (x > pawn.CurrentPosition._PosX || x < pawn.CurrentPosition._PosX)
{
templist.Add(pawnMoveList[i]);
}
}
else
{
if (x == pawn.CurrentPosition._PosX)
{
if (y == (pawn.CurrentPosition._PosY + 2) || y == (pawn.CurrentPosition._PosY - 2))
{
if (pawn.PieceColor == Color.White)
{
if (EncounterAlly(pawn.CurrentPosition._PosX, pawn.CurrentPosition._PosY + 1, pawn, gameboard))
{
}
else
{
templist.Add(pawnMoveList[i]);
break;
}
}
else if (pawn.PieceColor == Color.Black)
{
if (EncounterAlly(pawn.CurrentPosition._PosX, pawn.CurrentPosition._PosY - 1, pawn, gameboard))
{
}
else
{
templist.Add(pawnMoveList[i]);
break;
}
}
}
if (y == (pawn.CurrentPosition._PosY + 1) || y == (pawn.CurrentPosition._PosY - 1))
{
templist.Add(pawnMoveList[i]);
}
}
}
}
}
}
/// <summary>
/// The specific move logic that concerns Rook
/// </summary>
/// <param name="rook"></param>
/// <param name="gameboard"></param>
private void RookMovement(Pieces rook, List <Pieces> gameboard)
{
templist.AddRange(AddHorizontalAndVerticalMoves(rook, gameboard));
}
