// init() initializes piece square tables: the white halves of the tables are
// copied from Bonus[] adding the piece value, then the black halves of the
// tables are initialized by flipping and changing the sign of the white scores.
void init() {
for (PieceType pt = PAWN; pt <= KING; ++pt)
{
PieceValue[MG][make_piece(BLACK, pt)] = PieceValue[MG][pt];
PieceValue[EG][make_piece(BLACK, pt)] = PieceValue[EG][pt];
Score v = make_score(PieceValue[MG][pt], PieceValue[EG][pt]);
for (Square s = SQ_A1; s <= SQ_H8; ++s)
{
int edgeDistance = file_of(s) < FILE_E ? file_of(s) : FILE_H - file_of(s);
psq[BLACK][pt][~s] = -(psq[WHITE][pt][s] = v + Bonus[pt][rank_of(s)][edgeDistance]);
}
}
}
static void string_output_put(void* _self, char ch) {
StringOutput* self = _self;
if (self->offset == self->last->size) {
make_piece(self);
}
self->last->data[self->offset++] = ch;
}
// init() initializes piece-square tables: the white halves of the tables are
// copied from Bonus[] adding the piece value, then the black halves of the
// tables are initialized by flipping and changing the sign of the white scores.
void init() {
for (PieceType pt = PAWN; pt <= KING; ++pt)
{
PieceValue[MG][make_piece(BLACK, pt)] = PieceValue[MG][pt];
PieceValue[EG][make_piece(BLACK, pt)] = PieceValue[EG][pt];
Score v = make_score(PieceValue[MG][pt], PieceValue[EG][pt]);
for (Square s = SQ_A1; s <= SQ_H8; ++s)
{
File f = std::min(file_of(s), FILE_H - file_of(s));
psq[WHITE][pt][ s] = v + Bonus[pt][rank_of(s)][f];
psq[BLACK][pt][~s] = -psq[WHITE][pt][s];
}
}
}
static void string_output_write(void* _self, const char* src, size_t n) {
StringOutput* self = _self;
size_t fill = MIN(n, self->last->size - self->offset);
memcpy(self->last->data + self->offset, src, fill);
if (fill == n) {
self->offset += n;
} else {
make_piece(self);
string_output_write(self, src + fill, n - fill);
}
}
MoveStack* generate<MV_EVASION>(const Position& pos, MoveStack* mlist)
{
assert(pos.pos_is_ok());
assert(pos.in_check());
Color us = pos.side_to_move();
#if 0
#if !defined(NDEBUG)
Square ksq = pos.sq_king<us>();
assert(pos.piece_on(ksq) == make_piece(us, OU));
#endif
#endif
return (us == BLACK) ? pos.generate_evasion<BLACK>(mlist) : pos.generate_evasion<WHITE>(mlist);
}
bool move_is_legal(const Position& pos, Move move)
{
Move m = move;
assert(is_ok(m));
Color us = pos.side_to_move();
Square from = from_sq(m);
Square to = to_sq(m);
assert(color_of(pos.piece_moved(m)) == us);
assert(pos.piece_on(pos.king_square(us)) == make_piece(us, KING));
PieceType pfr = type_of(pos.piece_on(from));
PieceType pto= type_of(pos.piece_on(to));
Bitboard pawns = pos.pieces(~us, PAWN);
Bitboard knights = pos.pieces(~us, KNIGHT);
Bitboard cannons = pos.pieces(~us, CANNON);
Bitboard rooks = pos.pieces(~us, ROOK);
Bitboard occ = pos.pieces();
Bitboard occl90 = pos.piecesl90();
occl90 ^= square_rotate_l90_bb(from);
occ ^= from;
if(pto == NO_PIECE_TYPE)
{
occl90 ^= square_rotate_l90_bb(to);
occ ^= to;
}
Square ksq = pos.king_square(us);
if(ksq == from)
ksq = to;
if (pto != NO_PIECE_TYPE)
{
switch(pto)
{
case PAWN:
pawns ^= to;
break;
case KNIGHT:
knights ^= to;
break;
case ROOK:
rooks ^= to;
break;
case CANNON:
cannons ^= to;
break;
}
}
if((PseudoAttacks[ROOK][ksq]& cannons) &&(cannon_control_bb(ksq, occ,occl90) & cannons)) return false;
if((PseudoAttacks[ROOK][ksq]& rooks) && (rook_attacks_bb(ksq,occ,occl90)& rooks) ) return false;
if( knight_attackers_to_bb(ksq, knights, occ) ) return false;
if( pos.attacks_from_pawn_nomask(ksq, us) & pawns ) return false;
if((PseudoAttacks[ROOK][ksq]& pos.king_square(~us)) && (rook_attacks_bb(ksq,occ,occl90)& pos.king_square(~us))) return false;//╤таЁ
return true;
}
