evalu.cpp

将UCOS与UCGUI整合到一起,并在BORLAND C++上运行通过的源程序.

                                   /*  The piece on the Square  */
                if (mating && (piececount != pawn))
                {
                    if (piececount == king)
                        if (color == losingcolor)  /*  Mating evaluation  */
                        {
                            posval = 128 - 16 * distan[rank]
                                - 12 * distan[line];
                            if (distan[rank] == 3)
                                posval -= 16;
                        }
                        else
                        {
                            posval = 128 - 4 * kingdist;
                            if ((distan[rank] >= 2) || (distan[line] == 3))
                                posval -= 16;
                        }
                }
                else
                {
                    temp = pvcontrol[color][rook][square];
                    temp2 = pvcontrol[color][bishop][square];
                    /*  Normal evaluation function  */
                    switch (piececount)
                    {
                        case king :
                            if (materiallevel <= 0) posval = -2 * dist;
                            break;
                        case queen :
                            posval = (temp + temp2) >> 2;
                            break;
                        case rook :
                            posval = temp;
                            break;
                        case bishop :
                            posval = temp2;
                            break;
                        case knight :
                            cnt = 0;
                            for (dir = 0; dir < 8; dir++)
                            {
                                sq = square + KnightDir[dir];
                                if (!(sq & 0x88))
                                    cnt += attackvalue[color][sq];
                            }
                            posval = (cnt >> 1) - dist * 3;
                            break;
                        case pawn :
                            if ((rank != 0) && (rank != 7))
                                posval = pawnrank[rank] +
                                  pawnfilefactor[line] * (rank + 2) - 12;
                    }
                }
                PVTable[color][piececount][square] = posval;
            }
         }
      }

    /*  Calculate pawntab (indicates which squares contain pawns)  */

    for (color = white; color <= black; ((int)color)++)
        for (rank = 0; rank < 8; rank++)
            pawntab[color][rank] = 0;
    for (square = 0x77; square >= 0; square--)
        if (!(square & 0x88))
            if (Board[square].piece == pawn)
            {
                rank = square >> 4;
                if (Board[square].color == black) rank = 7 - rank;
                pawntab[Board[square].color][rank] |=
                    filebittab[square & 7];
            }
    for (color = white; color <= black; ((int)color)++)  /*  initialize pawnbit  */
    {
        pawnbit[-1][color].one = pawnbit[-1][color].dob = 0;
        for (rank = 1; rank < 7; rank++)
        {
            temp = pawntab[color][rank];
            pawnbit[-1][color].dob |= (pawnbit[-1][color].one & temp);
            pawnbit[-1][color].one |= temp;
        }
    }
    /*  Calculate pawnstructurevalue  */
    RootValue = pawnstrval(-1, Player) - pawnstrval(-1, Opponent);

    /*  Calculate static value for pawn structure  */
    for (color = white; color <= black; ((int)color)++)
    {
        oppcolor = (COLORTYPE)(1 - color);
        pawnfiletab = leftsidetab = rightsidetab = behindoppass = 0;
        oppasstab = 0xff;
        for (rank = 1; rank < 7; rank++)
        /*  Squares where opponents pawns are passed pawns  */
        {
            oppasstab &= (~(pawnfiletab | leftsidetab | rightsidetab));
            /*  Squares behind the opponents passed pawns  */
            behindoppass |= (oppasstab & pawntab[oppcolor][7 - rank]);
            /*  squares which are covered by a pawn  */
            leftchaintab = leftsidetab;
            rightchaintab = rightsidetab;
            pawnfiletab = pawntab[color][rank]; /*  squares w/ pawns  */
            /*  squares w/ a pawn beside them  */
            leftsidetab = (pawnfiletab << 1) & 0xff;
            rightsidetab = (pawnfiletab >> 1) & 0xff;
            sidetab = leftsidetab | rightsidetab;
            chaintab = leftchaintab | rightchaintab;
            /*  squares covering a pawn  */
            temp = pawntab[color][rank+1];
            leftcovertab = (temp << 1) & 0xff;
            rightcovertab = (temp >> 1 ) & 0xff;
            sq = rank << 4;
            if (color == black) sq ^= 0x70;
            bit = 1;
            while (bit)
            {
                strval = 0;
                if (bit & sidetab)
                    strval = SIDEPAWN;
                else if (bit & chaintab)
                    strval = CHAINPAWN;
                if (bit & leftcovertab)
                    strval += COVERPAWN;
                if (bit & rightcovertab)
                    strval += COVERPAWN;
                if (bit & pawnfiletab)
                    strval += NOTMOVEPAWN;
                PVTable[color][pawn][sq] += strval;
                if ((materiallevel <= 0) || (oppcolor != ProgramColor))
                {
                    if (bit & oppasstab)
                        PVTable[oppcolor][pawn][sq] += passpawnrank[7 - rank];
                    if (bit & behindoppass)
                    {
                        temp = sq ^ 0x10;
                        for (tempcolor = black; tempcolor >= white
                            ; ((int)tempcolor)--)
                        {
                            PVTable[tempcolor][rook][sq] +=
                                ROOKBEHINDPASSPAWN;
                            if (rank == 6)
                                PVTable[tempcolor][rook][temp] +=
                                    ROOKBEHINDPASSPAWN;
                        }
                    }
                }
                sq++;
                bit = (bit << 1) & 0xff;
            }
        }
    }
    /*  Calculate penalty for blocking center pawns with a bishop  */
    for (sq = 3; sq < 5; sq ++)
    {
        if ((Board[sq + 0x10].piece == pawn) && (Board[sq + 0x10].color
            == white))
            PVTable[white][bishop][sq + 0x20] -= BISHOPBLOCKVALUE;
        if ((Board[sq+0x60].piece == pawn) && (Board[sq+0x60].color == black))
            PVTable[black][bishop][sq+0x50] -= BISHOPBLOCKVALUE;
    }
    for (square = 0x77; square >= 0; square--) /*  Calculate RootValue  */
        if (!(square & 0x88))
            if (Board[square].piece != empty)
                if (Board[square].color == Player)
                    RootValue +=
                        PiecePosVal(Board[square].piece, Player, square);
                else
                    RootValue -=
                        PiecePosVal(Board[square].piece, Opponent, square);
}

/****************************************************************************/

int value;
SQUARETYPE castsquare, cornersquare, epsquare;


/*
 *  Update pawnbit and calculates value when a pawn is removed from line
 */

inline int decpawnstrval(COLORTYPE color, FILETYPE line)
{
    temp = ~filebittab[line];
    pawnbit[Depth][color].one = (pawnbit[Depth][color].one & temp) |
            pawnbit[Depth][color].dob;
    pawnbit[Depth][color].dob &= temp;
    return (pawnstrval(Depth, color) - pawnstrval(Depth - 1, color));
}

/*
 *  Update pawnbit and calculates value when a pawn moves
 *  from old to new1 file
 */

static int movepawnstrval(COLORTYPE color, FILETYPE new1, FILETYPE old)
{
    temp = filebittab[new1];
    temp2 = ~filebittab[old];
    pawnbit[Depth][color].dob |= (pawnbit[Depth][color].one & temp);
    pawnbit[Depth][color].one = ((pawnbit[Depth][color].one & temp2) |
        pawnbit[Depth][color].dob) | temp;
    pawnbit[Depth][color].dob &= temp2;
    return (pawnstrval(Depth, color) - pawnstrval(Depth - 1, color));
}

/****************************************************************************/

/*
 *  Calculate STATIC evaluation of the move
 */

int StatEvalu(MOVETYPE *move)
{
    value = 0;
    if (move->spe)
        if (move->movpiece == king)
        {
            GenCastSquare(move->new1, &castsquare, &cornersquare);
            value = PiecePosVal(rook, Player, castsquare) -
                    PiecePosVal(rook,Player, cornersquare);
            if (move->new1 > move->old)
                value += castvalue[shrt-1];
            else
                value += castvalue[lng-1];
        }
        else if (move->movpiece == pawn)
        {
            epsquare = move->new1 - PawnDir[Player];  /*  E.p. capture  */
            value = PiecePosVal(pawn, Opponent, epsquare);
        }
        else            /*  Pawnpromotion  */
            value = PiecePosVal(move->movpiece, Player, move->old) -
                    PiecePosVal(pawn, Player, move->old) +
                    decpawnstrval(Player, move->old & 7);
        if (move->content != empty)  /*  normal moves  */
        {
            value += PiecePosVal(move->content, Opponent, move->new1);
            /*  Penalty for exchanging pieces when behind in material  */
            if (abs(MainEvalu) >= 0x100)
                if (move->content != pawn)
                    if ((ProgramColor == Opponent) == (MainEvalu >= 0))
                        value -= EXCHANGEVALUE;
        }
        pawnbit[Depth][black] = pawnbit[Depth - 1][black];  /*  calculate pawnbit  */
        pawnbit[Depth][white] = pawnbit[Depth - 1][white];
        if ((move->movpiece == pawn) && ((move->content != empty)
                || move->spe))
            value += movepawnstrval(Player, move->new1 & 7, move->old & 7);
        if ((move->content == pawn) || move->spe && (move->movpiece == pawn))
            value -= decpawnstrval(Opponent, move->new1 & 7);
        /*  Calculate value of move  */
        return (value + PiecePosVal(move->movpiece, Player, move->new1)-
                PiecePosVal(move->movpiece, Player, move->old));
}