chessai.chess.gamestate

  1import typing
  2
  3import edq.util.serial
  4
  5import chessai.chess.piece
  6import chessai.core.action
  7import chessai.core.gamestate
  8
  9class GameState(chessai.core.gamestate.GameState):
 10    """ A game state specific to a standard Pacman game. """
 11
 12    def game_complete(self) -> tuple[list[chessai.core.types.Color], float]:
 13        winners = self.get_winners()
 14
 15        # Score is based on white's perspective using standard chess scoring.
 16        if (chessai.core.types.Color.WHITE in winners):
 17            score = 1.0
 18        elif (chessai.core.types.Color.BLACK in winners):
 19            score = 0.0
 20        else:
 21            score = 0.5
 22
 23        return (winners, score)
 24
 25    def is_check(self, color: chessai.core.types.Color, started_in_check: bool = True) -> bool:
 26        # Find the king of the given color.
 27        king_coordinate = self.get_king_coordinate(color)
 28
 29        # If there is no King, they cannot be in check.
 30        # This should never happen in standard chess games with valid positions.
 31        if (king_coordinate is None):
 32            return False
 33
 34        # Get the most recent action to try to avoid work when not doing a full check.
 35        previous_action = self.get_previous_action()
 36
 37        if ((not started_in_check) and isinstance(previous_action, chessai.core.action.MoveAction)):
 38            check_potential = self._has_check_potential(king_coordinate, previous_action)
 39        else:
 40            check_potential = True
 41
 42        # Skip checking moves that could not have opened us to check.
 43        if (not check_potential):
 44            return False
 45
 46        # Check if any opponent piece can attack the king's coordinate.
 47        old_turn = self.turn
 48        self.turn = color.opposite()
 49
 50        try:
 51            opponent_actions = self._get_pseudo_legal_moves()
 52            for action in opponent_actions:
 53                if (action.end_coordinate == king_coordinate):
 54                    return True
 55
 56            return False
 57        finally:
 58            self.turn = old_turn
 59
 60    def get_king_coordinate(self, color: chessai.core.types.Color) -> chessai.core.coordinate.Coordinate | None:
 61        """ Get the coordinate of the king for the given color. """
 62
 63        for (file, rank_dict) in self.board.pieces.items():
 64            for (rank, piece) in rank_dict.items():
 65                if ((piece.color == color) and (isinstance(piece, chessai.chess.piece.King))):
 66                    return chessai.core.coordinate.Coordinate(file, rank)
 67
 68        # If there's no king, the position is invalid, which should never happen.
 69        return None
 70
 71    def _has_check_potential(self, king_coordinate: chessai.core.coordinate.Coordinate, previous_action: chessai.core.action.MoveAction) -> bool:
 72        """
 73        Returns whether the player who played the most recent move could be in check.
 74
 75        Assumes the player was not in check before playing their most recent move.
 76        """
 77
 78        # Check if the king just moved, which means it could have moved into check.
 79        if (previous_action.end_coordinate == king_coordinate):
 80            return True
 81
 82        # Check if a piece moved on the king's file, rank, or diagonal.
 83        # This move would allow for discovery checks.
 84        if ((previous_action.start_coordinate.file == king_coordinate.file) or (previous_action.start_coordinate.rank == king_coordinate.rank)):
 85            # A piece moved on the king's rank or file, so the king could be under attack from a rook or queen.
 86            return True
 87
 88        # Check the diagonal.
 89        file_delta = abs(king_coordinate.file - previous_action.start_coordinate.file)
 90        rank_delta = abs(king_coordinate.rank - previous_action.start_coordinate.rank)
 91
 92        # If a piece moved away from the king's diagonal, the king could be under attack from a bishop or queen.
 93        return file_delta == rank_delta
 94
 95    def _should_reset_halfmove_clock(self, action: chessai.core.action.Action, piece: chessai.core.piece.Piece) -> bool:
 96        return (isinstance(piece, chessai.chess.piece.Pawn))
 97
 98    def _get_pseudo_legal_moves(self) -> list[chessai.core.action.MoveAction]:
 99        # Get the base movement from all pieces.
100        actions = self._get_base_move_actions()
101
102        # Add any castling moves.
103        actions.extend(self._get_castling_moves())
104
105        # Add any pawn double pushes.
106        actions.extend(self._get_pawn_double_pushes())
107
108        # Add any en-passant captures.
109        actions.extend(self._get_en_passant_captures())
110
111        return actions
112
113    def _get_base_move_actions(self) -> list[chessai.core.action.MoveAction]:
114        """
115        Expands all movement vectors from the pieces on the board.
116        Pieces will move until they can capture or reach the end of the board.
117
118        Detects when pawns reach the end of the board and can be promoted.
119        """
120
121        actions: list[chessai.core.action.MoveAction] = []
122
123        # Determine the rank for pawn promotions.
124        if (self.turn == chessai.core.types.Color.WHITE):
125            promotion_rank = self.board.num_ranks - 1
126        else:
127            promotion_rank = 0
128
129        for (file, rank_dict) in self.board.pieces.items():
130            for (rank, piece) in rank_dict.items():
131                if (piece.color != self.turn):
132                    continue
133
134                for movement_vector in piece.move_vectors():
135                    current_rank = rank
136                    current_file = file
137
138                    coordinate = chessai.core.coordinate.Coordinate(file, rank)
139
140                    num_repetitions = movement_vector.num_repetitions
141                    while (num_repetitions != 0):
142                        current_file += movement_vector.file_delta
143                        current_rank += movement_vector.rank_delta
144                        if (not self.board.is_within_bounds(current_file, current_rank)):
145                            break
146
147                        occupant = self.board.get(current_file, current_rank)
148
149                        is_occupied = occupant is not None
150                        is_enemy    = (occupant is not None) and (occupant.color != piece.color)
151                        is_ally     = (occupant is not None) and (occupant.color == piece.color)
152
153                        # No movement type can move on top of an ally.
154                        if (is_ally):
155                            break
156
157                        # Push movement types cannot capture.
158                        if ((movement_vector.kind == chessai.core.piece.MoveKind.PUSH) and is_occupied):
159                            break
160
161                        # Capture movement types must target an enemy.
162                        if ((movement_vector.kind == chessai.core.piece.MoveKind.CAPTURE) and (not is_enemy)):
163                            break
164
165                        current_coordinate = chessai.core.coordinate.Coordinate(current_file, current_rank)
166
167                        # Check if this action would lead to a pawn promotion.
168                        if ((isinstance(piece, chessai.chess.piece.Pawn)) and (current_coordinate.rank == promotion_rank)):
169                            actions.extend(self._get_promotion_actions(coordinate, current_coordinate))
170                        else:
171                            actions.append(chessai.core.action.MoveAction(coordinate, current_coordinate))
172
173                        if (is_occupied):
174                            break
175
176                        num_repetitions -= 1
177
178        return actions
179
180    def _process_special_move(self,
181                              action: chessai.core.action.Action,
182                              piece: chessai.core.piece.Piece) -> tuple[bool, chessai.core.coordinate.Coordinate | None]:
183        if (not isinstance(action, chessai.core.action.MoveAction)):
184            return False, None
185
186        # Update castling rights.
187        self._update_castling_rights(action, piece)
188
189        # Handle promoting pieces.
190        if isinstance(action, chessai.core.action.PromotionAction):
191            self._handle_promotion(action, piece)
192
193        # Detect castling by seeing if the king moved more than two files.
194        if ((isinstance(piece, chessai.chess.piece.King))
195                and (action.start_coordinate.file_distance(action.end_coordinate) > 1)):
196            self._handle_castling(action, piece)
197            return False, None
198
199        # Detect en-passant by checking if a pawn moves diagonally to an empty coordinate.
200        if ((isinstance(piece, chessai.chess.piece.Pawn))
201                and (action.start_coordinate.file_distance(action.end_coordinate) == 1)
202                and (self.get(action.end_coordinate) is None)):
203            en_passant_coordinate = self._handle_en_passant(action, piece)
204            return True, en_passant_coordinate
205
206        return False, None
207
208    def is_insufficient_material(self) -> bool:
209        # Meta actions cannot cause a game to become in an insufficient material state.
210        if (not isinstance(self.get_previous_action(), chessai.core.action.MoveAction)):
211            return False
212
213        for color in chessai.core.types.Color:
214            if (not self._is_insufficient_material(color)):
215                return False
216
217        return True
218
219    def _is_insufficient_material(self, color: chessai.core.types.Color) -> bool:
220        """
221        Checks if the given color has insufficient winning material.
222
223        This is guaranteed to return False if the color can still win the game.
224
225        The converse does not necessarily hold: only material is considered (including bishop square colors), not piece positions.
226        Fortress positions or forced lines may still return False even with no winning continuation.
227        """
228
229        own_pieces = {}
230        opponent_pieces = {}
231
232        own_knights = False
233        own_bishops: dict[chessai.core.coordinate.Coordinate, chessai.core.piece.Piece] = {}
234
235        for (file, rank_dict) in self.board.pieces.items():
236            for (rank, piece) in rank_dict.items():
237                coordinate = chessai.core.coordinate.Coordinate(file, rank)
238
239                if (piece.color == color):
240                    own_pieces[coordinate] = piece
241
242                    # Pawns, rooks, or queens are always sufficient material.
243                    if (isinstance(piece, (chessai.chess.piece.Pawn, chessai.chess.piece.Rook, chessai.chess.piece.Queen))):
244                        return False
245
246                    if (isinstance(piece, chessai.chess.piece.Knight)):
247                        own_knights = True
248                    elif (isinstance(piece, chessai.chess.piece.Bishop)):
249                        own_bishops[coordinate] = piece
250                else:
251                    opponent_pieces[coordinate] = piece
252
253        # Knights are only insufficient material if:
254        # (1) We do not have any other pieces, including more than one knight.
255        # (2) The opponent does not have pawns, knights, bishops or rooks.
256        #     These would allow selfmate.
257        if (own_knights):
258            # Sufficient material via case 1.
259            if (len(own_pieces) > 2):
260                return False
261
262            for piece in opponent_pieces.values():
263                if isinstance(piece, (chessai.chess.piece.Knight, chessai.chess.piece.Bishop, chessai.chess.piece.Rook, chessai.chess.piece.Pawn)):
264                    # Sufficient material via case 2.
265                    return False
266
267            return True
268
269        # Bishops are only insufficient material if:
270        # (1) We do not have any other pieces, including bishops of the opposite color.
271        # (2) The opponent does not have bishops of the opposite color, pawns or knights.
272        #     These would allow selfmate.
273        if (len(own_bishops) > 0):
274            square_parities = set()
275            for (coordinate, _) in own_bishops.items():
276                square_parity = (coordinate.file + coordinate.rank) % 2
277                square_parities.add(square_parity)
278
279            # Sufficient material via case 1.
280            if (len(square_parities) > 1):
281                return False
282
283            for piece in opponent_pieces.values():
284                # Sufficient material via case 2 (using pawns or knights).
285                if (isinstance(piece, (chessai.chess.piece.Pawn, chessai.chess.piece.Knight))):
286                    return False
287
288            opponent_bishop_parities = set()
289            for (coordinate, piece) in opponent_pieces.items():
290                if (isinstance(piece, chessai.chess.piece.Bishop)):
291                    opponent_parity = (coordinate.file + coordinate.rank) % 2
292                    opponent_bishop_parities.add(opponent_parity)
293
294            opponent_has_opposite_bishops = bool(opponent_bishop_parities - square_parities)
295
296            # Determine sufficient material via case 2 when the opponent has bishops of the opposite color.
297            return (not opponent_has_opposite_bishops)
298
299        # King alone.
300        return True
301
302    def _handle_castling(self, action: chessai.core.action.MoveAction, piece: chessai.core.piece.Piece) -> None:
303        # Build the rook action for castling.
304        rook_action: chessai.core.action.Action | None = None
305        back_rank = action.start_coordinate.rank
306
307        if (action.end_coordinate.file > action.start_coordinate.file):
308            # Kingside: rook moves from the h-file to just right of the king's destination.
309            rook_start = chessai.core.coordinate.Coordinate(self.board.num_files - 1, back_rank)
310            rook_end   = chessai.core.coordinate.Coordinate(action.end_coordinate.file - 1, back_rank)
311        else:
312            # Queenside: rook moves from the a-file to just left of the king's destination.
313            rook_start = chessai.core.coordinate.Coordinate(0, back_rank)
314            rook_end   = chessai.core.coordinate.Coordinate(action.end_coordinate.file + 1, back_rank)
315
316        rook_action = chessai.core.action.MoveAction(rook_start, rook_end)
317
318        # Move the rook for castling.
319        self.board.push(rook_action)
320
321    def _handle_en_passant(self,
322                           action: chessai.core.action.MoveAction,
323                           piece: chessai.core.piece.Piece,
324                           ) -> chessai.core.coordinate.Coordinate | None:
325        # The captured pawn is on the same rank as the moving pawn, on the destination file.
326        captured_piece_coordinate = chessai.core.coordinate.Coordinate(
327            action.end_coordinate.file,
328            action.start_coordinate.rank,
329        )
330
331        # Remove the en-passant captured pawn from its actual coordinate.
332        self.board.remove(captured_piece_coordinate)
333
334        # Return the en-passant target coordinate, based on the action.
335        return self._compute_en_passant(action, piece)
336
337    def _handle_promotion(self, action: chessai.core.action.PromotionAction, piece: chessai.core.piece.Piece) -> None:
338        # Handle promotion by replacing the pawn with the promoted piece.
339        self.board.set(action.promotion, action.end_coordinate)
340
341    def _get_castling_moves(self) -> list[chessai.core.action.MoveAction]:
342        """ Get all pseudo-legal castling moves for the current player. """
343
344        # Determine the back rank and castling rights for the current player.
345        if (self.turn == chessai.core.types.Color.WHITE):
346            back_rank           = 0
347            kingside_rights     = self.castling_rights.white_kingside
348            queenside_rights    = self.castling_rights.white_queenside
349        else:
350            back_rank           = self.board.num_ranks - 1
351            kingside_rights     = self.castling_rights.black_kingside
352            queenside_rights    = self.castling_rights.black_queenside
353
354        if ((not kingside_rights) and (not queenside_rights)):
355            return []
356
357        # Find the king.
358        king_coordinate = self.get_king_coordinate(self.turn)
359
360        # The king must be on the back rank to castle.
361        if ((king_coordinate is None) or (king_coordinate.rank != back_rank)):
362            return []
363
364        # Get the coordinates that the opponent can attack,
365        # as a castling move cannot pass through a square that is attacked.
366        attacked_coordinates = self.get_attacked_coordinates(self.turn.opposite())
367
368        # The king cannot castle if it is being attacked.
369        if (king_coordinate in attacked_coordinates):
370            return []
371
372        actions: list[chessai.core.action.MoveAction] = []
373
374        # Add Kingside castling.
375        if (kingside_rights):
376            rook_cordinate = chessai.core.coordinate.Coordinate((self.board.num_files - 1), back_rank)
377            rook_piece = self.get(rook_cordinate)
378
379            # Check that the files to the right of the king and left of the rook are empty.
380            all_safe = True
381            file = king_coordinate.file + 1
382            while (file < rook_cordinate.file):
383                empty_coord = chessai.core.coordinate.Coordinate(file, back_rank)
384
385                if (empty_coord in attacked_coordinates):
386                    all_safe = False
387                    break
388
389                if (self.board.has_piece(empty_coord)):
390                    all_safe = False
391                    break
392
393                file = file + 1
394
395            if ((rook_piece is not None)
396                    and (isinstance(rook_piece, chessai.chess.piece.Rook))
397                    and (rook_piece.color == self.turn)
398                    and (all_safe)):
399                king_dest = chessai.core.coordinate.Coordinate((self.board.num_files - 2), back_rank)
400                actions.append(chessai.core.action.MoveAction(king_coordinate, king_dest))
401
402        # Add Queenside castling.
403        if (queenside_rights):
404            rook_cordinate = chessai.core.coordinate.Coordinate(0, back_rank)
405            rook_piece = self.get(rook_cordinate)
406
407            # Check that the files to the right of the king and left of the rook are empty.
408            all_safe = True
409            file = king_coordinate.file - 1
410            while (file > 0):
411                empty_coord = chessai.core.coordinate.Coordinate(file, back_rank)
412
413                if (empty_coord in attacked_coordinates):
414                    all_safe = False
415                    break
416
417                if (self.board.has_piece(empty_coord)):
418                    all_safe = False
419                    break
420
421                file = file - 1
422
423            if ((rook_piece is not None)
424                    and (isinstance(rook_piece, chessai.chess.piece.Rook))
425                    and (rook_piece.color == self.turn)
426                    and (all_safe)):
427                king_dest = chessai.core.coordinate.Coordinate(2, back_rank)
428                actions.append(chessai.core.action.MoveAction(king_coordinate, king_dest))
429
430        return actions
431
432    def _get_pawn_double_pushes(self) -> list[chessai.core.action.MoveAction]:
433        """ Get all pseudo-legal pawn double push moves for the current player. """
434
435        if (self.turn == chessai.core.types.Color.WHITE):
436            start_rank = 1
437            direction  = 1
438        else:
439            start_rank = self.board.num_ranks - 2
440            direction  = -1
441
442        actions: list[chessai.core.action.MoveAction] = []
443
444        for (file, rank_dict) in self.board.pieces.items():
445            if (start_rank not in rank_dict):
446                continue
447
448            piece = rank_dict[start_rank]
449            if (piece.color != self.turn):
450                continue
451
452            if (not isinstance(piece, chessai.chess.piece.Pawn)):
453                continue
454
455            coordinate = chessai.core.coordinate.Coordinate(file, start_rank)
456
457            # Both the single and double push coordinates must be empty.
458            single_push_coord = coordinate.offset(0, direction)
459            if (self.board.has_piece(single_push_coord)):
460                continue
461
462            double_push_coord = coordinate.offset(0, direction * 2)
463            if (self.board.has_piece(double_push_coord)):
464                continue
465
466            actions.append(chessai.core.action.MoveAction(coordinate, double_push_coord))
467
468        return actions
469
470    def _get_en_passant_captures(self) -> list[chessai.core.action.MoveAction]:
471        """ Get all pseudo-legal en-passant captures for the current player. """
472
473        actions: list[chessai.core.action.MoveAction] = []
474
475        if (self.en_passant_coordinate is None):
476            return actions
477
478        if (self.turn == chessai.core.types.Color.WHITE):
479            # The en-passant coordinate encodes the coordinate that must be taken.
480            # So, the pawn that can attack it will be one rank below for white.
481            capturing_rank = self.en_passant_coordinate.rank - 1
482        else:
483            capturing_rank = self.en_passant_coordinate.rank + 1
484
485        # The pawn will have to be on an adjacent file.
486        for file_delta in [-1, 1]:
487            candidate_capture_coord = chessai.core.coordinate.Coordinate(
488                self.en_passant_coordinate.file + file_delta,
489                capturing_rank,
490            )
491
492            if (not self.board.is_within_bounds(candidate_capture_coord.file, candidate_capture_coord.rank)):
493                continue
494
495            piece = self.get(candidate_capture_coord)
496            if (piece is None):
497                continue
498
499            if (not isinstance(piece, chessai.chess.piece.Pawn)):
500                continue
501
502            if (piece.color != self.turn):
503                continue
504
505            actions.append(chessai.core.action.MoveAction(candidate_capture_coord, self.en_passant_coordinate))
506
507        return actions
508
509    def _get_promotion_actions(self,
510            start_coordinate: chessai.core.coordinate.Coordinate,
511            end_coordinate: chessai.core.coordinate.Coordinate) -> list[chessai.core.action.MoveAction]:
512        """
513        Expand a pawn move that reaches the back rank into one action per promotable piece type.
514
515        Called when a pawn reaches the back rank of the opposing side.
516        Always returns exactly four actions (queen, rook, bishop, knight).
517        """
518
519        return [
520            chessai.core.action.PromotionAction(start_coordinate, end_coordinate, chessai.chess.piece.Queen(self.turn)),
521            chessai.core.action.PromotionAction(start_coordinate, end_coordinate, chessai.chess.piece.Rook(self.turn)),
522            chessai.core.action.PromotionAction(start_coordinate, end_coordinate, chessai.chess.piece.Bishop(self.turn)),
523            chessai.core.action.PromotionAction(start_coordinate, end_coordinate, chessai.chess.piece.Knight(self.turn)),
524        ]
525
526    def _update_castling_rights(self,
527            action: chessai.core.action.MoveAction,
528            piece: chessai.core.piece.Piece) -> None:
529        """ Revoke castling rights that are no longer valid after the given move. """
530
531        white_kingside_rook  = chessai.core.coordinate.Coordinate(self.board.num_files - 1, 0)
532        white_queenside_rook = chessai.core.coordinate.Coordinate(0, 0)
533        black_kingside_rook  = chessai.core.coordinate.Coordinate(self.board.num_files - 1, self.board.num_ranks - 1)
534        black_queenside_rook = chessai.core.coordinate.Coordinate(0, self.board.num_ranks - 1)
535
536        # King moves, which forfeits both rights for that color.
537        if (isinstance(piece, chessai.chess.piece.King)):
538            if (piece.color == chessai.core.types.Color.WHITE):
539                self.castling_rights = self.castling_rights.revoke_rights(chessai.core.castling.ALL_WHITE_RIGHTS)
540            else:
541                self.castling_rights = self.castling_rights.revoke_rights(chessai.core.castling.ALL_BLACK_RIGHTS)
542
543        # Rook moves from its starting coordinate.
544        if (action.start_coordinate == white_kingside_rook):
545            self.castling_rights = self.castling_rights.revoke_rights(chessai.core.castling.WHITE_KINGSIDE_RIGHTS)
546
547        if (action.start_coordinate == white_queenside_rook):
548            self.castling_rights = self.castling_rights.revoke_rights(chessai.core.castling.WHITE_QUEENSIDE_RIGHTS)
549
550        if (action.start_coordinate == black_kingside_rook):
551            self.castling_rights = self.castling_rights.revoke_rights(chessai.core.castling.BLACK_KINGSIDE_RIGHTS)
552
553        if (action.start_coordinate == black_queenside_rook):
554            self.castling_rights = self.castling_rights.revoke_rights(chessai.core.castling.BLACK_QUEENSIDE_RIGHTS)
555
556        # Rook captured on its starting coordinate.
557        if (action.end_coordinate == white_kingside_rook):
558            self.castling_rights = self.castling_rights.revoke_rights(chessai.core.castling.WHITE_KINGSIDE_RIGHTS)
559
560        if (action.end_coordinate == white_queenside_rook):
561            self.castling_rights = self.castling_rights.revoke_rights(chessai.core.castling.WHITE_QUEENSIDE_RIGHTS)
562
563        if (action.end_coordinate == black_kingside_rook):
564            self.castling_rights = self.castling_rights.revoke_rights(chessai.core.castling.BLACK_KINGSIDE_RIGHTS)
565
566        if (action.end_coordinate == black_queenside_rook):
567            self.castling_rights = self.castling_rights.revoke_rights(chessai.core.castling.BLACK_QUEENSIDE_RIGHTS)
568
569    def _compute_en_passant(self,
570            action: chessai.core.action.MoveAction,
571            piece: chessai.core.piece.Piece) -> chessai.core.coordinate.Coordinate | None:
572        """
573        Return the new en-passant target coordinate after this move, or None.
574
575        A target coordinate is set only when a pawn advances two ranks.
576        The target is the coordinate the pawn passed through (i.e. one rank behind the destination), which is standard FEN notation.
577        """
578
579        if (not isinstance(piece, chessai.chess.piece.Pawn)):
580            return None
581
582        if (action.start_coordinate.rank_distance(action.end_coordinate) != 2):
583            return None
584
585        # The en-passant target is the coordinate the pawn skipped over.
586        passed_rank = (action.start_coordinate.rank + action.end_coordinate.rank) // 2
587        return chessai.core.coordinate.Coordinate(action.start_coordinate.file, passed_rank)
588
589    def copy(self,
590            context: typing.Union[edq.util.serial.SerializationContext, None] = None,
591            ) -> 'GameState':
592        new_state = super().copy()
593        new_state = typing.cast(GameState, new_state)
594
595        return new_state
596
597def base_eval(
598        state: chessai.core.gamestate.GameState,
599        action: chessai.core.action.Action | None = None,
600        agent: typing.Any | None = None,
601        **kwargs: typing.Any) -> float:
602    """
603    The most basic evaluation function, which just uses the difference in piece value on the board.
604    """
605
606    piece_values: dict[type[chessai.core.piece.Piece], int] = {
607        chessai.chess.piece.Pawn: 1,
608        chessai.chess.piece.Knight: 3,
609        chessai.chess.piece.Bishop: 3,
610        chessai.chess.piece.Rook: 5,
611        chessai.chess.piece.Queen: 9,
612        chessai.chess.piece.King: 9999,
613    }
614
615    # The difference in pieces from white's perspective.
616    board_value = 0
617    for piece in state.board.all_pieces():
618        piece_value = piece_values.get(type(piece), 0)
619        if (piece.color == chessai.core.types.Color.WHITE):
620            board_value += piece_value
621        else:
622            board_value -= piece_value
623
624    if (state.turn == chessai.core.types.Color.WHITE):
625        return board_value
626
627    # The piece difference is the opposite for black.
628    return -1 * board_value