position.cpp

超强国际象棋引擎

// pst.cpp

// includes

#include "config.h"
#include "piece.h"
#include "position.h"

// macros

#define P(piece_12,square_64,stage) (pst[(piece_12)][(square_64)][(stage)])

static const int pawn_file[8] =
    {
    -3, -1, +0, +1, +1, +0, -1, -3,
    };

static const int knight_line[8] =
    {
    -4, -2, +0, +1, +1, +0, -2, -4,
    };

static const int knight_rank[8] =
    {
    -2, -1, +0, +1, +2, +3, +2, +1,
    };

static const int bishop_line[8] =
    {
    -3, -1, +0, +1, +1, +0, -1, -3,
    };

static const int rook_file[8] =
    {
    -2, -1, +0, +1, +1, +0, -1, -2,
    };

static const int queen_line[8] =
    {
    -3, -1, +0, +1, +1, +0, -1, -3,
    };

static const int king_line[8] =
    {
    -3, -1, +0, +1, +1, +0, -1, -3,
    };

static const int king_file[8] =
    {
    +3, +4, +2, +0, +0, +2, +4, +3,
    };

static const int king_rank[8] =
    {
    +1, +0, -2, -3, -4, -5, -6, -7,
    };

// variables

sint16 pst[12][64][2];

// prototypes

static int square_make(int file, int rank);

static int square_file(int square);
static int square_rank(int square);
static int square_opp(int square);

// functions

// pst_init()

void pst_init()
    {

    int i;
    int piece, sq, stage;

    // init

    for ( piece = 0; piece < 12; piece++ )
        {
        for ( sq = 0; sq < 64; sq++ )
            {
            for ( stage = 0; stage < 2; stage++ )
                {
                P(piece, sq, stage) = 0;
                }
            }
        }

    // pawns

    piece = 0;

    // file

    for ( sq = 0; sq < 64; sq++ )
        {
        P(piece, sq, 0) += pawn_file[square_file(sq)] * 5;
        }

    // centre control

    P(piece, (023), 0) += 10;
    P(piece, (024), 0) += 10;

    P(piece, (033), 0) += 20;
    P(piece, (034), 0) += 20;

    P(piece, (043), 0) += 10;
    P(piece, (044), 0) += 10;

    // knights

    piece = 2;

    // centre

    for ( sq = 0; sq < 64; sq++ )
        {
        P(piece, sq, 0) += knight_line[square_file(sq)] * 5;
        P(piece, sq, 0) += knight_line[square_rank(sq)] * 5;
        P(piece, sq, 1) += knight_line[square_file(sq)] * 5;
        P(piece, sq, 1) += knight_line[square_rank(sq)] * 5;
        }

    // rank

    for ( sq = 0; sq < 64; sq++ )
        {
        P(piece, sq, 0) += knight_rank[square_rank(sq)] * 5;
        }

    // back rank

    for ( sq = (000); sq <= (007); sq++ )
        {
        P(piece, sq, 0) -= 0;
        }

    // "trapped"

    P(piece, (070), 0) -= 100;
    P(piece, (077), 0) -= 100;

    // bishops

    piece = 4;

    // centre

    for ( sq = 0; sq < 64; sq++ )
        {
        P(piece, sq, 0) += bishop_line[square_file(sq)] * 2;
        P(piece, sq, 0) += bishop_line[square_rank(sq)] * 2;
        P(piece, sq, 1) += bishop_line[square_file(sq)] * 3;
        P(piece, sq, 1) += bishop_line[square_rank(sq)] * 3;
        }

    // back rank

    for ( sq = (000); sq <= (007); sq++ )
        {
        P(piece, sq, 0) -= 10;
        }

    // main diagonals

    for ( i = 0; i < 8; i++ )
        {
        sq = square_make(i, i);
        P(piece, sq, 0) += 4;
        P(piece, square_opp(sq), 0) += 4;
        }

    // rooks

    piece = 6;

    // file

    for ( sq = 0; sq < 64; sq++ )
        {
        P(piece, sq, 0) += rook_file[square_file(sq)] * 3;
        }

    // queens

    piece = 8;

    // centre

    for ( sq = 0; sq < 64; sq++ )
        {
        P(piece, sq, 0) += queen_line[square_file(sq)] * 0;
        P(piece, sq, 0) += queen_line[square_rank(sq)] * 0;
        P(piece, sq, 1) += queen_line[square_file(sq)] * 4;
        P(piece, sq, 1) += queen_line[square_rank(sq)] * 4;
        }

    // back rank

    for ( sq = (000); sq <= (007); sq++ )
        {
        P(piece, sq, 0) -= 5;
        }

    // weight

    for ( sq = 0; sq < 64; sq++ )
        {
        P(piece, sq, 0) = (P(piece, sq, 0) * 256) / 256;
        P(piece, sq, 1) = (P(piece, sq, 1) * 256) / 256;
        }

    // kings

    piece = 10;

    // centre

    for ( sq = 0; sq < 64; sq++ )
        {
        P(piece, sq, 1) += king_line[square_file(sq)] * 12;
        P(piece, sq, 1) += king_line[square_rank(sq)] * 12;
        }

    // file

    for ( sq = 0; sq < 64; sq++ )
        {
        P(piece, sq, 0) += king_file[square_file(sq)] * 10;
        }

    // rank

    for ( sq = 0; sq < 64; sq++ )
        {
        P(piece, sq, 0) += king_rank[square_rank(sq)] * 10;
        }

    // symmetry copy for black

    for ( piece = 0; piece < 12; piece += 2 )
        {
        for ( sq = 0; sq < 64; sq++ )
            {
            for ( stage = 0; stage < 2; stage++ )
                {
                P(piece + 1, sq, stage) = -P(piece, square_opp(sq), stage);
                }
            }
        }
    }

// square_make()

static int square_make(int file, int rank)
    {

    return (rank << 3) | file;
    }

// square_file()

static int square_file(int square)
    {

    return square & 7;
    }

// square_rank()

static int square_rank(int square)
    {

    return square >> 3;
    }

// square_opp()

static int square_opp(int square)
    {

    return square ^ 070;
    }

// end of pst.cpp