kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-05-02 09:39:36 +00:00
Code Issues Releases Wiki Activity

Use operator~ to flip colors and squares

Browse source 
More natural and nicer. Idea from Critter.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2012-01-12 19:31:18 +01:00
parent c549f71f64
commit d98150dffc
8 changed files with 76 additions and 76 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
src/endgame.cpp
View file

@ -205,10 +205,10 @@ Value Endgame<KPK>::operator()(const Position& pos) const {
} }
else else
{ {
wksq = flip(pos.king_square(BLACK)); wksq = ~pos.king_square(BLACK);
bksq = flip(pos.king_square(WHITE)); bksq = ~pos.king_square(WHITE);
wpsq = flip(pos.piece_list(BLACK, PAWN)[0]); wpsq = ~pos.piece_list(BLACK, PAWN)[0];
stm = flip(pos.side_to_move()); stm = ~pos.side_to_move();
} }
if (file_of(wpsq) >= FILE_E) if (file_of(wpsq) >= FILE_E)
@ -251,10 +251,10 @@ Value Endgame<KRKP>::operator()(const Position& pos) const {
if (strongerSide == BLACK) if (strongerSide == BLACK)
{ {
wksq = flip(wksq); wksq = ~wksq;
wrsq = flip(wrsq); wrsq = ~wrsq;
bksq = flip(bksq); bksq = ~bksq;
bpsq = flip(bpsq); bpsq = ~bpsq;
} }
Square queeningSq = make_square(file_of(bpsq), RANK_1); Square queeningSq = make_square(file_of(bpsq), RANK_1);
@ -491,11 +491,11 @@ ScaleFactor Endgame<KRPKR>::operator()(const Position& pos) const {
// pawn is on the left half of the board. // pawn is on the left half of the board.
if (strongerSide == BLACK) if (strongerSide == BLACK)
{ {
wksq = flip(wksq); wksq = ~wksq;
wrsq = flip(wrsq); wrsq = ~wrsq;
wpsq = flip(wpsq); wpsq = ~wpsq;
bksq = flip(bksq); bksq = ~bksq;
brsq = flip(brsq); brsq = ~brsq;
} }
if (file_of(wpsq) > FILE_D) if (file_of(wpsq) > FILE_D)
{ {
@ -867,10 +867,10 @@ ScaleFactor Endgame<KPKP>::operator()(const Position& pos) const {
if (strongerSide == BLACK) if (strongerSide == BLACK)
{ {
wksq = flip(wksq); wksq = ~wksq;
bksq = flip(bksq); bksq = ~bksq;
wpsq = flip(wpsq); wpsq = ~wpsq;
stm = flip(stm); stm = ~stm;
} }
if (file_of(wpsq) >= FILE_E) if (file_of(wpsq) >= FILE_E)

2
src/endgame.h
View file

@ -82,7 +82,7 @@ struct EndgameBase {
template<EndgameType E, typename T = typename eg_family<E>::type> template<EndgameType E, typename T = typename eg_family<E>::type>
struct Endgame : public EndgameBase<T> { struct Endgame : public EndgameBase<T> {
explicit Endgame(Color c) : strongerSide(c), weakerSide(flip(c)) {} explicit Endgame(Color c) : strongerSide(c), weakerSide(~c) {}
Color color() const { return strongerSide; } Color color() const { return strongerSide; }
T operator()(const Position&) const; T operator()(const Position&) const;

6
src/evaluate.cpp
View file

@ -887,7 +887,7 @@ namespace {
for (c = WHITE; c <= BLACK; c++) for (c = WHITE; c <= BLACK; c++)
{ {
// Skip if other side has non-pawn pieces // Skip if other side has non-pawn pieces
if (pos.non_pawn_material(flip(c))) if (pos.non_pawn_material(~c))
continue; continue;
b = ei.pi->passed_pawns(c); b = ei.pi->passed_pawns(c);
@ -900,7 +900,7 @@ namespace {
// Compute plies to queening and check direct advancement // Compute plies to queening and check direct advancement
movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(c, s) == RANK_2); movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(c, s) == RANK_2);
oppMovesToGo = square_distance(pos.king_square(flip(c)), queeningSquare) - int(c != pos.side_to_move()); oppMovesToGo = square_distance(pos.king_square(~c), queeningSquare) - int(c != pos.side_to_move());
pathDefended = ((ei.attackedBy[c][0] & queeningPath) == queeningPath); pathDefended = ((ei.attackedBy[c][0] & queeningPath) == queeningPath);
if (movesToGo >= oppMovesToGo && !pathDefended) if (movesToGo >= oppMovesToGo && !pathDefended)
@ -928,7 +928,7 @@ namespace {
return SCORE_ZERO; return SCORE_ZERO;
winnerSide = (pliesToQueen[WHITE] < pliesToQueen[BLACK] ? WHITE : BLACK); winnerSide = (pliesToQueen[WHITE] < pliesToQueen[BLACK] ? WHITE : BLACK);
loserSide = flip(winnerSide); loserSide = ~winnerSide;
// Step 3. Can the losing side possibly create a new passed pawn and thus prevent the loss? // Step 3. Can the losing side possibly create a new passed pawn and thus prevent the loss?
b = candidates = pos.pieces(PAWN, loserSide); b = candidates = pos.pieces(PAWN, loserSide);

8
src/movegen.cpp
View file

@ -49,7 +49,7 @@ namespace {
Square rfrom = pos.castle_rook_square(CR[us]); Square rfrom = pos.castle_rook_square(CR[us]);
Square kto = relative_square(us, Side == KING_SIDE ? SQ_G1 : SQ_C1); Square kto = relative_square(us, Side == KING_SIDE ? SQ_G1 : SQ_C1);
Square rto = relative_square(us, Side == KING_SIDE ? SQ_F1 : SQ_D1); Square rto = relative_square(us, Side == KING_SIDE ? SQ_F1 : SQ_D1);
Bitboard enemies = pos.pieces(flip(us)); Bitboard enemies = pos.pieces(~us);
assert(!pos.in_check()); assert(!pos.in_check());
assert(pos.piece_on(kfrom) == make_piece(us, KING)); assert(pos.piece_on(kfrom) == make_piece(us, KING));
@ -346,13 +346,13 @@ MoveStack* generate(const Position& pos, MoveStack* mlist) {
Bitboard target; Bitboard target;
if (Type == MV_CAPTURE) if (Type == MV_CAPTURE)
target = pos.pieces(flip(us)); target = pos.pieces(~us);
else if (Type == MV_NON_CAPTURE) else if (Type == MV_NON_CAPTURE)
target = pos.empty_squares(); target = pos.empty_squares();
else if (Type == MV_NON_EVASION) else if (Type == MV_NON_EVASION)
target = pos.pieces(flip(us)) | pos.empty_squares(); target = pos.pieces(~us) | pos.empty_squares();
mlist = generate_piece_moves<PAWN, Type>(pos, mlist, us, target); mlist = generate_piece_moves<PAWN, Type>(pos, mlist, us, target);
mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target); mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
@ -444,7 +444,7 @@ MoveStack* generate<MV_EVASION>(const Position& pos, MoveStack* mlist) {
checkersCnt++; checkersCnt++;
checksq = pop_1st_bit(&b); checksq = pop_1st_bit(&b);
assert(color_of(pos.piece_on(checksq)) == flip(us)); assert(color_of(pos.piece_on(checksq)) == ~us);
switch (type_of(pos.piece_on(checksq))) switch (type_of(pos.piece_on(checksq)))
{ {

82
src/position.cpp
View file

@ -78,7 +78,7 @@ namespace {
CheckInfo::CheckInfo(const Position& pos) { CheckInfo::CheckInfo(const Position& pos) {
Color them = flip(pos.side_to_move()); Color them = ~pos.side_to_move();
ksq = pos.king_square(them); ksq = pos.king_square(them);
pinned = pos.pinned_pieces(); pinned = pos.pinned_pieces();
@ -233,7 +233,7 @@ void Position::from_fen(const string& fenStr, bool isChess960) {
st->value = compute_value(); st->value = compute_value();
st->npMaterial[WHITE] = compute_non_pawn_material(WHITE); st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
st->npMaterial[BLACK] = compute_non_pawn_material(BLACK); st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(flip(sideToMove)); st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
chess960 = isChess960; chess960 = isChess960;
assert(pos_is_ok()); assert(pos_is_ok());
@ -356,8 +356,8 @@ Bitboard Position::hidden_checkers() const {
// Pinned pieces protect our king, dicovery checks attack the enemy king // Pinned pieces protect our king, dicovery checks attack the enemy king
Bitboard b, result = 0; Bitboard b, result = 0;
Bitboard pinners = pieces(FindPinned ? flip(sideToMove) : sideToMove); Bitboard pinners = pieces(FindPinned ? ~sideToMove : sideToMove);
Square ksq = king_square(FindPinned ? sideToMove : flip(sideToMove)); Square ksq = king_square(FindPinned ? sideToMove : ~sideToMove);
// Pinners are sliders, that give check when candidate pinned is removed // Pinners are sliders, that give check when candidate pinned is removed
pinners &= (pieces(ROOK, QUEEN) & PseudoAttacks[ROOK][ksq]) pinners &= (pieces(ROOK, QUEEN) & PseudoAttacks[ROOK][ksq])
@ -449,7 +449,7 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
assert(is_ok(m)); assert(is_ok(m));
assert(pinned == pinned_pieces()); assert(pinned == pinned_pieces());
Color us = side_to_move(); Color us = sideToMove;
Square from = from_sq(m); Square from = from_sq(m);
assert(color_of(piece_on(from)) == us); assert(color_of(piece_on(from)) == us);
@ -460,7 +460,7 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
// the move is made. // the move is made.
if (is_enpassant(m)) if (is_enpassant(m))
{ {
Color them = flip(us); Color them = ~us;
Square to = to_sq(m); Square to = to_sq(m);
Square capsq = to + pawn_push(them); Square capsq = to + pawn_push(them);
Square ksq = king_square(us); Square ksq = king_square(us);
@ -483,7 +483,7 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
// square is attacked by the opponent. Castling moves are checked // square is attacked by the opponent. Castling moves are checked
// for legality during move generation. // for legality during move generation.
if (type_of(piece_on(from)) == KING) if (type_of(piece_on(from)) == KING)
return is_castle(m) || !(attackers_to(to_sq(m)) & pieces(flip(us))); return is_castle(m) || !(attackers_to(to_sq(m)) & pieces(~us));
// A non-king move is legal if and only if it is not pinned or it // A non-king move is legal if and only if it is not pinned or it
// is moving along the ray towards or away from the king. // is moving along the ray towards or away from the king.
@ -514,7 +514,7 @@ bool Position::move_is_legal(const Move m) const {
bool Position::is_pseudo_legal(const Move m) const { bool Position::is_pseudo_legal(const Move m) const {
Color us = sideToMove; Color us = sideToMove;
Color them = flip(sideToMove); Color them = ~sideToMove;
Square from = from_sq(m); Square from = from_sq(m);
Square to = to_sq(m); Square to = to_sq(m);
Piece pc = piece_on(from); Piece pc = piece_on(from);
@ -612,7 +612,7 @@ bool Position::is_pseudo_legal(const Move m) const {
{ {
Bitboard b = occupied_squares(); Bitboard b = occupied_squares();
clear_bit(&b, from); clear_bit(&b, from);
if (attackers_to(to_sq(m), b) & pieces(flip(us))) if (attackers_to(to_sq(m), b) & pieces(~us))
return false; return false;
} }
else else
@ -640,7 +640,7 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
assert(is_ok(m)); assert(is_ok(m));
assert(ci.dcCandidates == discovered_check_candidates()); assert(ci.dcCandidates == discovered_check_candidates());
assert(color_of(piece_moved(m)) == side_to_move()); assert(color_of(piece_moved(m)) == sideToMove);
Square from = from_sq(m); Square from = from_sq(m);
Square to = to_sq(m); Square to = to_sq(m);
@ -655,7 +655,7 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
{ {
// For pawn and king moves we need to verify also direction // For pawn and king moves we need to verify also direction
if ( (pt != PAWN && pt != KING) if ( (pt != PAWN && pt != KING)
|| !squares_aligned(from, to, king_square(flip(side_to_move())))) || !squares_aligned(from, to, king_square(~sideToMove)))
return true; return true;
} }
@ -663,9 +663,9 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
if (!is_special(m)) if (!is_special(m))
return false; return false;
Color us = side_to_move(); Color us = sideToMove;
Bitboard b = occupied_squares(); Bitboard b = occupied_squares();
Square ksq = king_square(flip(us)); Square ksq = king_square(~us);
// Promotion with check ? // Promotion with check ?
if (is_promotion(m)) if (is_promotion(m))
@ -763,8 +763,8 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
return; return;
} }
Color us = side_to_move(); Color us = sideToMove;
Color them = flip(us); Color them = ~us;
Square from = from_sq(m); Square from = from_sq(m);
Square to = to_sq(m); Square to = to_sq(m);
Piece piece = piece_on(from); Piece piece = piece_on(from);
@ -957,7 +957,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
} }
// Finish // Finish
sideToMove = flip(sideToMove); sideToMove = ~sideToMove;
st->value += (sideToMove == WHITE ? TempoValue : -TempoValue); st->value += (sideToMove == WHITE ? TempoValue : -TempoValue);
assert(pos_is_ok()); assert(pos_is_ok());
@ -971,7 +971,7 @@ void Position::undo_move(Move m) {
assert(is_ok(m)); assert(is_ok(m));
sideToMove = flip(sideToMove); sideToMove = ~sideToMove;
if (is_castle(m)) if (is_castle(m))
{ {
@ -979,8 +979,8 @@ void Position::undo_move(Move m) {
return; return;
} }
Color us = side_to_move(); Color us = sideToMove;
Color them = flip(us); Color them = ~us;
Square from = from_sq(m); Square from = from_sq(m);
Square to = to_sq(m); Square to = to_sq(m);
Piece piece = piece_on(to); Piece piece = piece_on(to);
@ -1075,7 +1075,7 @@ void Position::do_castle_move(Move m) {
Square kto, kfrom, rfrom, rto, kAfter, rAfter; Square kto, kfrom, rfrom, rto, kAfter, rAfter;
Color us = side_to_move(); Color us = sideToMove;
Square kBefore = from_sq(m); Square kBefore = from_sq(m);
Square rBefore = to_sq(m); Square rBefore = to_sq(m);
@ -1159,10 +1159,10 @@ void Position::do_castle_move(Move m) {
st->rule50 = 0; st->rule50 = 0;
// Update checkers BB // Update checkers BB
st->checkersBB = attackers_to(king_square(flip(us))) & pieces(us); st->checkersBB = attackers_to(king_square(~us)) & pieces(us);
// Finish // Finish
sideToMove = flip(sideToMove); sideToMove = ~sideToMove;
st->value += (sideToMove == WHITE ? TempoValue : -TempoValue); st->value += (sideToMove == WHITE ? TempoValue : -TempoValue);
} }
else else
@ -1193,7 +1193,7 @@ void Position::do_null_move(StateInfo& backupSt) {
dst->rule50 = src->rule50; dst->rule50 = src->rule50;
dst->pliesFromNull = src->pliesFromNull; dst->pliesFromNull = src->pliesFromNull;
sideToMove = flip(sideToMove); sideToMove = ~sideToMove;
if (Do) if (Do)
{ {
@ -1263,7 +1263,7 @@ int Position::see(Move m) const {
// Handle en passant moves // Handle en passant moves
if (is_enpassant(m)) if (is_enpassant(m))
{ {
Square capQq = to - pawn_push(side_to_move()); Square capQq = to - pawn_push(sideToMove);
assert(capturedType == NO_PIECE_TYPE); assert(capturedType == NO_PIECE_TYPE);
assert(type_of(piece_on(capQq)) == PAWN); assert(type_of(piece_on(capQq)) == PAWN);
@ -1279,7 +1279,7 @@ int Position::see(Move m) const {
attackers = attackers_to(to, occ); attackers = attackers_to(to, occ);
// If the opponent has no attackers we are finished // If the opponent has no attackers we are finished
stm = flip(color_of(piece_on(from))); stm = ~color_of(piece_on(from));
stmAttackers = attackers & pieces(stm); stmAttackers = attackers & pieces(stm);
if (!stmAttackers) if (!stmAttackers)
return PieceValueMidgame[capturedType]; return PieceValueMidgame[capturedType];
@ -1317,7 +1317,7 @@ int Position::see(Move m) const {
// Remember the value of the capturing piece, and change the side to // Remember the value of the capturing piece, and change the side to
// move before beginning the next iteration. // move before beginning the next iteration.
capturedType = pt; capturedType = pt;
stm = flip(stm); stm = ~stm;
stmAttackers = attackers & pieces(stm); stmAttackers = attackers & pieces(stm);
// Stop before processing a king capture // Stop before processing a king capture
@ -1401,7 +1401,7 @@ Key Position::compute_key() const {
if (ep_square() != SQ_NONE) if (ep_square() != SQ_NONE)
result ^= zobEp[ep_square()]; result ^= zobEp[ep_square()];
if (side_to_move() == BLACK) if (sideToMove == BLACK)
result ^= zobSideToMove; result ^= zobSideToMove;
return result; return result;
@ -1465,7 +1465,7 @@ Score Position::compute_value() const {
result += pst(make_piece(c, pt), pop_1st_bit(&b)); result += pst(make_piece(c, pt), pop_1st_bit(&b));
} }
result += (side_to_move() == WHITE ? TempoValue / 2 : -TempoValue / 2); result += (sideToMove == WHITE ? TempoValue / 2 : -TempoValue / 2);
return result; return result;
} }
@ -1561,7 +1561,7 @@ void Position::init() {
for (Square s = SQ_A1; s <= SQ_H8; s++) for (Square s = SQ_A1; s <= SQ_H8; s++)
{ {
pieceSquareTable[p][s] = ps + PSQT[p][s]; pieceSquareTable[p][s] = ps + PSQT[p][s];
pieceSquareTable[p+8][flip(s)] = -pieceSquareTable[p][s]; pieceSquareTable[p+8][~s] = -pieceSquareTable[p][s];
} }
} }
} }
@ -1581,27 +1581,27 @@ void Position::flip_me() {
// Board // Board
for (Square s = SQ_A1; s <= SQ_H8; s++) for (Square s = SQ_A1; s <= SQ_H8; s++)
if (!pos.square_is_empty(s)) if (!pos.square_is_empty(s))
put_piece(Piece(pos.piece_on(s) ^ 8), flip(s)); put_piece(Piece(pos.piece_on(s) ^ 8), ~s);
// Side to move // Side to move
sideToMove = flip(pos.side_to_move()); sideToMove = ~pos.side_to_move();
// Castling rights // Castling rights
if (pos.can_castle(WHITE_OO)) if (pos.can_castle(WHITE_OO))
set_castle_right(BLACK, flip(pos.castle_rook_square(WHITE_OO))); set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OO));
if (pos.can_castle(WHITE_OOO)) if (pos.can_castle(WHITE_OOO))
set_castle_right(BLACK, flip(pos.castle_rook_square(WHITE_OOO))); set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OOO));
if (pos.can_castle(BLACK_OO)) if (pos.can_castle(BLACK_OO))
set_castle_right(WHITE, flip(pos.castle_rook_square(BLACK_OO))); set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OO));
if (pos.can_castle(BLACK_OOO)) if (pos.can_castle(BLACK_OOO))
set_castle_right(WHITE, flip(pos.castle_rook_square(BLACK_OOO))); set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OOO));
// En passant square // En passant square
if (pos.st->epSquare != SQ_NONE) if (pos.st->epSquare != SQ_NONE)
st->epSquare = flip(pos.st->epSquare); st->epSquare = ~pos.st->epSquare;
// Checkers // Checkers
st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(flip(sideToMove)); st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
// Hash keys // Hash keys
st->key = compute_key(); st->key = compute_key();
@ -1643,7 +1643,7 @@ bool Position::pos_is_ok(int* failedStep) const {
if (failedStep) *failedStep = 1; if (failedStep) *failedStep = 1;
// Side to move OK? // Side to move OK?
if (side_to_move() != WHITE && side_to_move() != BLACK) if (sideToMove != WHITE && sideToMove != BLACK)
return false; return false;
// Are the king squares in the position correct? // Are the king squares in the position correct?
@ -1672,8 +1672,8 @@ bool Position::pos_is_ok(int* failedStep) const {
if (failedStep) (*failedStep)++; if (failedStep) (*failedStep)++;
if (debugKingCapture) if (debugKingCapture)
{ {
Color us = side_to_move(); Color us = sideToMove;
Color them = flip(us); Color them = ~us;
Square ksq = king_square(them); Square ksq = king_square(them);
if (attackers_to(ksq) & pieces(us)) if (attackers_to(ksq) & pieces(us))
return false; return false;
@ -1710,7 +1710,7 @@ bool Position::pos_is_ok(int* failedStep) const {
{ {
// The en passant square must be on rank 6, from the point of view of the // The en passant square must be on rank 6, from the point of view of the
// side to move. // side to move.
if (relative_rank(side_to_move(), ep_square()) != RANK_6) if (relative_rank(sideToMove, ep_square()) != RANK_6)
return false; return false;
} }

2
src/position.h
View file

@ -392,7 +392,7 @@ inline Bitboard Position::pinned_pieces() const {
} }
inline bool Position::pawn_is_passed(Color c, Square s) const { inline bool Position::pawn_is_passed(Color c, Square s) const {
return !(pieces(PAWN, flip(c)) & passed_pawn_mask(c, s)); return !(pieces(PAWN, ~c) & passed_pawn_mask(c, s));
} }
inline Key Position::key() const { inline Key Position::key() const {

2
src/search.cpp
View file

@ -1393,7 +1393,7 @@ split_point_start: // At split points actual search starts from here
from = from_sq(move); from = from_sq(move);
to = to_sq(move); to = to_sq(move);
them = flip(pos.side_to_move()); them = ~pos.side_to_move();
ksq = pos.king_square(them); ksq = pos.king_square(them);
kingAtt = pos.attacks_from<KING>(ksq); kingAtt = pos.attacks_from<KING>(ksq);
pc = pos.piece_on(from); pc = pos.piece_on(from);

16
src/types.h
View file

@ -334,6 +334,14 @@ extern const Value PieceValueMidgame[17];
extern const Value PieceValueEndgame[17]; extern const Value PieceValueEndgame[17];
extern int SquareDistance[64][64]; extern int SquareDistance[64][64];
inline Color operator~(Color c) {
return Color(c ^ 1);
}
inline Square operator~(Square s) {
return Square(s ^ 56);
}
inline Value mate_in(int ply) { inline Value mate_in(int ply) {
return VALUE_MATE - ply; return VALUE_MATE - ply;
} }
@ -354,10 +362,6 @@ inline Color color_of(Piece p) {
return Color(p >> 3); return Color(p >> 3);
} }
inline Color flip(Color c) {
return Color(c ^ 1);
}
inline Square make_square(File f, Rank r) { inline Square make_square(File f, Rank r) {
return Square((r << 3) | f); return Square((r << 3) | f);
} }
@ -374,10 +378,6 @@ inline Rank rank_of(Square s) {
return Rank(s >> 3); return Rank(s >> 3);
} }
inline Square flip(Square s) {
return Square(s ^ 56);
}
inline Square mirror(Square s) { inline Square mirror(Square s) {
return Square(s ^ 7); return Square(s ^ 7);
} }