package chess import ( "errors" "mchess_server/types" "github.com/samber/lo" ) type Position map[types.Coordinate]Piece type Board struct { position Position history []types.Move colorToMove types.ChessColor state types.AdditionalState } func newBoard() Board { return Board{ position: make(Position), history: make([]types.Move, 0), colorToMove: types.White, state: types.AdditionalState{}, } } func (b *Board) Init() { var coord types.Coordinate for i := 1; i <= 8; i++ { coord.Row = 2 coord.Col = i b.position[coord] = Pawn{Color: types.White} coord.Row = 7 coord.Col = i b.position[coord] = Pawn{Color: types.Black} } b.position[types.Coordinate{Row: 1, Col: 1}] = Rook{Color: types.White} b.position[types.Coordinate{Row: 1, Col: 2}] = Knight{Color: types.White} b.position[types.Coordinate{Row: 1, Col: 3}] = Bishop{Color: types.White} b.position[types.Coordinate{Row: 1, Col: 4}] = Queen{Color: types.White} b.position[types.Coordinate{Row: 1, Col: 5}] = King{Color: types.White} b.position[types.Coordinate{Row: 1, Col: 6}] = Bishop{Color: types.White} b.position[types.Coordinate{Row: 1, Col: 7}] = Knight{Color: types.White} b.position[types.Coordinate{Row: 1, Col: 8}] = Rook{Color: types.White} b.position[types.Coordinate{Row: 8, Col: 1}] = Rook{Color: types.Black} b.position[types.Coordinate{Row: 8, Col: 2}] = Knight{Color: types.Black} b.position[types.Coordinate{Row: 8, Col: 3}] = Bishop{Color: types.Black} b.position[types.Coordinate{Row: 8, Col: 4}] = Queen{Color: types.Black} b.position[types.Coordinate{Row: 8, Col: 5}] = King{Color: types.Black} b.position[types.Coordinate{Row: 8, Col: 6}] = Bishop{Color: types.Black} b.position[types.Coordinate{Row: 8, Col: 7}] = Knight{Color: types.Black} b.position[types.Coordinate{Row: 8, Col: 8}] = Rook{Color: types.Black} } func (b *Board) CheckAndPlay(move types.Move) (bool, string) { // We make a copy of the original board to play moves on it, // We can play the move on it and then check if it is invalid tempBoard := b.getCopyOfBoard() //Check start square of move pieceAtStartSquare := tempBoard.getPieceAt(move.StartSquare) if pieceAtStartSquare == nil { return false, "no piece at start square" } move.ColorMoved = pieceAtStartSquare.GetColor() if move.ColorMoved != tempBoard.colorToMove { return false, "wrong color moved" } move.PieceMoved = GetShortNameForPiece(pieceAtStartSquare) //Check end square of move pieceAtEndSquare := tempBoard.getPieceAt(move.EndSquare) if pieceAtEndSquare != nil { if pieceAtEndSquare.GetColor() == pieceAtStartSquare.GetColor() { return false, "same-coloured piece at end square" } } wasSpecialMove := tempBoard.handleSpecialMove(move) if !wasSpecialMove { // At the moment, we do not need to check if the correct color is moving, //since we are only reading moves from the player whose turn it is. allMovesExceptBlocked := pieceAtStartSquare.GetAllNonBlockedMoves(tempBoard, move.StartSquare) legal := lo.Contains(allMovesExceptBlocked, move.EndSquare) if !legal { return false, "not a legal square" } //We play the move on the temporary board delete(tempBoard.position, move.StartSquare) tempBoard.position[move.EndSquare] = pieceAtStartSquare } kingAttacked, err := tempBoard.isKingOfMovingColorInCheck(move.ColorMoved) if err != nil { return false, "something went wrong" } if kingAttacked { return false, "king would be in check after move" } //Check for checkmat&e //Is every square that the king can move to attacked? And can no other //piece block? -> checkmate //only check if paths of attacking pieces can be blocked //Maybe for checking checkmate, we have to check the 'path' in which the //checkmate is given // |K| | | | |Q| // in this scenaria the path are all the squares between queen and king. // If a piece can be moved into the path, it is no checkmate //We play the move on the real board b.position = tempBoard.position b.history = tempBoard.history b.colorToMove = b.colorToMove.Opposite() b.appendMoveToHistory(move) pieceAtStartSquare.AfterMoveAction(b, move.StartSquare) return true, "" } func (b Board) isKingOfMovingColorInCheck(color types.ChessColor) (bool, error) { //Check if king of moving color is in check -> move not allowed //Do that by checking if the king is in a square attacked by the other color. ownKingCoordinate := b.getSquareOfPiece(King{Color: color}) if ownKingCoordinate == nil { return false, errors.New("no king found") } kingIsAttacked := b.isSquareAttacked(*ownKingCoordinate, color.Opposite()) if kingIsAttacked { return true, nil } return false, nil } func (b Board) getSquareOfPiece(piece Piece) *types.Coordinate { for k, v := range b.position { if v == piece { return &k } } return nil } func (b Board) isSquareAttacked(square types.Coordinate, byColor types.ChessColor) bool { var attackedSquares []types.Coordinate for square, piece := range b.position { if piece.GetColor() == byColor { attackedSquares = append(attackedSquares, piece.GetAllAttackedSquares(b, square)...) } } return lo.Contains(attackedSquares, square) } func (b Board) getPieceAt(coord types.Coordinate) Piece { piece, found := b.position[coord] if !found { return nil } return piece } func (b *Board) appendMoveToHistory(move types.Move) { b.history = append(b.history, move) } func (b Board) getLastMove() types.Move { if len(b.history) < 1 { return types.Move{} } return b.history[len(b.history)-1] } func (b Board) getCopyOfBoard() Board { return Board{ position: b.position.getCopyOfPosition(), history: b.history, colorToMove: b.colorToMove, state: b.state, } } func (p Position) getCopyOfPosition() Position { position := make(Position) for coord, piece := range p { position[coord] = piece } return position } func (b *Board) handleSpecialMove(move types.Move) bool { var was bool var pieceAtStartSquare = b.getPieceAt(move.StartSquare) switch piece := pieceAtStartSquare.(type) { case Pawn: was = piece.HandlePossiblePromotion(b, move) if !was { was = piece.HandleEnPassant(b, move, b.getLastMove()) } case King: was = piece.HandleCastling(b, move) } return was }