board.cpp

超强国际象棋引擎

// board.cpp

// includes

#include "attack.h"
#include "board.h"
#include "color.h"
#include "fen.h"
#include "hash.h"
#include "move_list.h"
#include "move.h"
#include "make_move.h"
#include "evasion.h"
#include "move_gen.h"
#include "valid_move.h"
#include "pawn.h"
#include "piece.h"
#include "position.h"
#include "util.h"
#include "values.h"

// functions

// board_is_ok()

bool board_is_ok(const board_t *board)
    {
    if(board == NULL)
        return false;
    else
        return true;
    }

// board_clear()

void board_clear(board_t *board)
    {
    int sq, sq_64;

    // edge squares

    for ( sq = 0; sq < 256; sq++ )
        {
        board->square[sq] = (1 << 4);
        }

    // empty squares

    for ( sq_64 = 0; sq_64 < 64; sq_64++ )
        {
        sq = SQUARE_FROM_64(sq_64);
        board->square[sq] = 0;
        }

    // misc

    board->turn = -1;
    board->flags = 0;
    board->ep_square = 0;
    board->ply_nb = 0;
    }

// board_copy()

void board_copy(board_t *dst, const board_t *src)
    {

    *dst = *src;
    }

// board_init_list()

void board_init_list(board_t *board)
    {

    int sq_64, sq, piece;
    int color, pos;
    int i, size;
    int square;
    int order;
    int file;

    // init

    for ( sq = 0; sq < 256; sq++ )
        {
        board->pos[sq] = -1;
        }

    board->piece_nb = 0;

    for ( piece = 0; piece < 12; piece++ )
        board->number[piece] = 0;

    // piece lists

    for ( color = 0; color < 2; color++ )
        {

        // piece list

        pos = 0;
        board->piece_material[color] = 0;

        for ( sq_64 = 0; sq_64 < 64; sq_64++ )
            {

            sq = SQUARE_FROM_64(sq_64);
            piece = board->square[sq];

            if(COLOUR_IS(piece, color) && !PIECE_IS_PAWN(piece))
                {

                board->pos[sq] = pos;
                board->piece[color][pos] = sq;
                pos++;

                board->piece_nb++;
                board->number[PIECE_TO_12(piece)]++;

                if(piece != ((1 << 7) | (1 << 0)) && piece != ((1 << 7) | (1 << 1)))
                    board->piece_material[color] += VALUE_PIECE(piece);
                }
            }

        if(board->number[4] >= 10)
            printf("illegal position!\n");

        board->piece[color][pos] = 0;
        board->piece_size[color] = pos;

        // MV sort

        size = board->piece_size[color];

        for ( i = 1; i < size; i++ )
            {

            square = board->piece[color][i];
            piece = board->square[square];
            order = PIECE_ORDER(piece);

            for ( pos = i; pos > 0 && order > PIECE_ORDER(board->square[(sq = board->piece[color][pos - 1])]); pos-- )
                {
                board->piece[color][pos] = sq;
                board->pos[sq] = pos;
                }

            board->piece[color][pos] = square;
            board->pos[square] = pos;
            }

        // pawn list

        for ( file = 0; file < 16; file++ )
            {
            board->pawn_file[color][file] = 0;
            }

        pos = 0;

        for ( sq_64 = 0; sq_64 < 64; sq_64++ )
            {

            sq = SQUARE_FROM_64(sq_64);
            piece = board->square[sq];

            if(COLOUR_IS(piece, color) && PIECE_IS_PAWN(piece))
                {

                board->pos[sq] = pos;
                board->pawn[color][pos] = sq;
                pos++;

                board->piece_nb++;
                board->number[PIECE_TO_12(piece)]++;
                board->pawn_file[color][SQUARE_FILE(sq)] |= BIT(PAWN_RANK(sq, color));

                board->piece_material[color] += VALUE_PIECE(piece);
                }
            }

        board->pawn[color][pos] = 0;
        board->pawn_size[color] = pos;
        }

    // last square

    board->cap_sq = 0;
    board->moving_piece = 0;

    // PST

    board->opening = board_opening(board);
    board->endgame = board_endgame(board);

    // hash key

    for ( i = 0; i < board->ply_nb; i++ )
        board->stack[i] = 0;
    board->sp = board->ply_nb;

    board->key = hash_key(board);
    board->pawn_key = hash_pawn_key(board);
    board->material_key = hash_material_key(board);
    }

// board_is_legal()

bool board_is_legal(const board_t *board)
    {
    return !IS_IN_CHECK(board, COLOUR_OPP(board->turn));
    }

// board_is_check()

bool board_is_check(const board_t *board)
    {
    return IS_IN_CHECK(board, board->turn);
    }

// board_is_mate()

bool board_is_mate(const board_t *board)
    {

    attack_t attack[1];
    attack_set(attack, board);

    if(!ATTACK_IN_CHECK(attack))
        return false; // not in check => not mate

    if(legal_evasion_exist(board, attack))
        return false; // legal move => not mate

    return true;      // in check and no legal move => mate
    }

// board_is_stalemate()

bool board_is_stalemate(board_t *board)
    {

    list_t list[1];
    int i, move;

    // init

    if(IS_IN_CHECK(board, board->turn))
        return false; // in check => not stalemate

    // move loop

    gen_moves(list, board);

    for ( i = 0; i < LIST_SIZE(list); i++ )
        {
        move = LIST_MOVE(list, i);

        if(pseudo_is_legal(move, board))
            return false; // legal move => not stalemate
        }

    return true;          // in check and no legal move => mate
    }

// board_is_repetition()

bool board_is_repetition(const board_t *board)
    {

    int i;

    // 50-move rule

    if(board->ply_nb >= 100)
        { // potential draw
        if(board->ply_nb > 100)
            return true;

        return !board_is_mate(board);
        }

    // position repetition

    for ( i = 4; i <= board->ply_nb; i += 2 )
        {
        if(board->stack[board->sp - i] == board->key)
            return true;
        }

    return false;
    }

// board_opening()

int board_opening(const board_t *board)
    {

    int opening;
    int color;
    const sq_t *ptr;
    int sq, piece;

    opening = 0;

    for ( color = 0; color < 2; color++ )
        {
        for ( ptr = &board->piece[color][0]; (sq = *ptr) != 0; ptr++ )
            {
            piece = board->square[sq];
            opening += PST(PIECE_TO_12(piece), SQUARE_TO_64(sq), 0);
            }

        for ( ptr = &board->pawn[color][0]; (sq = *ptr) != 0; ptr++ )
            {
            piece = board->square[sq];
            opening += PST(PIECE_TO_12(piece), SQUARE_TO_64(sq), 0);
            }
        }

    return opening;
    }

// board_endgame()

int board_endgame(const board_t *board)
    {

    int endgame;
    int color;
    const sq_t *ptr;
    int sq, piece;

    endgame = 0;

    for ( color = 0; color < 2; color++ )
        {
        for ( ptr = &board->piece[color][0]; (sq = *ptr) != 0; ptr++ )
            {
            piece = board->square[sq];
            endgame += PST(PIECE_TO_12(piece), SQUARE_TO_64(sq), 1);
            }

        for ( ptr = &board->pawn[color][0]; (sq = *ptr) != 0; ptr++ )
            {
            piece = board->square[sq];
            endgame += PST(PIECE_TO_12(piece), SQUARE_TO_64(sq), 1);
            }
        }

    return endgame;
    }

// end of board.cpp