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)); }