it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
-
+
++
Stockfish is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
}
- template<Color C>
- int generate_pawn_captures(const Position& pos, MoveStack* mlist) {
+ template<Color Us, Color Them, Bitboard TRank8BB, SquareDelta TDELTA_NE,
+ SquareDelta TDELTA_NW, SquareDelta TDELTA_N
+ >
- MoveStack* do_generate_pawn_captures(const Position& pos, MoveStack* mlist) {
++ MoveStack* do_generate_pawn_captures(const Position& pos, MoveStack* mlist) {
- static const PawnParams PP = (C == WHITE ? WhitePawnParams : BlackPawnParams);
-
- Bitboard pawns = pos.pawns(PP.us);
- Bitboard enemyPieces = pos.pieces_of_color(PP.them);
- Square sq;
- int n = 0;
+ Square to;
+ Bitboard pawns = pos.pawns(Us);
+ Bitboard enemyPieces = pos.pieces_of_color(Them);
// Captures in the a1-h8 (a8-h1 for black) direction
- Bitboard b1 = (C == WHITE ? pawns << 9 : pawns >> 7) & ~FileABB & enemyPieces;
+ Bitboard b1 = (Us == WHITE ? pawns << 9 : pawns >> 7) & ~FileABB & enemyPieces;
// Capturing promotions
- Bitboard b2 = b1 & PP.Rank8BB;
+ Bitboard b2 = b1 & TRank8BB;
while (b2)
{
- sq = pop_1st_bit(&b2);
- mlist[n++].move = make_promotion_move(sq - PP.DELTA_NE, sq, QUEEN);
+ to = pop_1st_bit(&b2);
+ (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, QUEEN);
}
// Capturing non-promotions
while (b1)
{
- sq = pop_1st_bit(&b1);
- mlist[n++].move = make_ep_move(sq, pos.ep_square());
+ to = pop_1st_bit(&b1);
+ (*mlist++).move = make_ep_move(to, pos.ep_square());
}
}
- return n;
+ return mlist;
}
- MoveStack* do_generate_pawn_noncaptures(const Position& pos, MoveStack* mlist) {
+ template<Color Us, Color Them, Bitboard TRank8BB, Bitboard TRank3BB,
+ SquareDelta TDELTA_NE, SquareDelta TDELTA_NW, SquareDelta TDELTA_N
+ >
++ MoveStack* do_generate_pawn_noncaptures(const Position& pos, MoveStack* mlist) {
- template<Color C>
- int generate_pawn_noncaptures(const Position& pos, MoveStack* mlist) {
-
- static const PawnParams PP = (C == WHITE ? WhitePawnParams : BlackPawnParams);
-
- Bitboard pawns = pos.pawns(PP.us);
- Bitboard enemyPieces = pos.pieces_of_color(PP.them);
+ Bitboard pawns = pos.pawns(Us);
+ Bitboard enemyPieces = pos.pieces_of_color(Them);
Bitboard emptySquares = pos.empty_squares();
Bitboard b1, b2;
- Square sq;
- int n = 0;
+ Square to;
// Underpromotion captures in the a1-h8 (a8-h1 for black) direction
- b1 = (C == WHITE ? pawns << 9 : pawns >> 7) & ~FileABB & enemyPieces & PP.Rank8BB;
+ b1 = (Us == WHITE ? pawns << 9 : pawns >> 7) & ~FileABB & enemyPieces & TRank8BB;
while (b1)
{
- sq = pop_1st_bit(&b1);
- mlist[n++].move = make_promotion_move(sq - PP.DELTA_NE, sq, ROOK);
- mlist[n++].move = make_promotion_move(sq - PP.DELTA_NE, sq, BISHOP);
- mlist[n++].move = make_promotion_move(sq - PP.DELTA_NE, sq, KNIGHT);
+ to = pop_1st_bit(&b1);
+ (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, ROOK);
+ (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, BISHOP);
+ (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, KNIGHT);
}
// Underpromotion captures in the h1-a8 (h8-a1 for black) direction
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
--
++
Stockfish is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
--
++
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
extern int generate_checks(const Position &pos, MoveStack *mlist, Bitboard dc);
extern int generate_evasions(const Position &pos, MoveStack *mlist);
extern int generate_legal_moves(const Position &pos, MoveStack *mlist);
-extern Move generate_move_if_legal(const Position &pos, Move m, Bitboard pinned);
+extern bool move_is_legal(const Position &pos, const Move m, Bitboard pinned);
+
+
#endif // !defined(MOVEGEN_H_INCLUDED)
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
-
+
++
Stockfish is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
}
void MovePicker::score_noncaptures() {
- Move m;\r
- int hs;\r
- \r
- for (int i = 0; i < numOfMoves; i++)\r
- {\r
- m = moves[i].move;\r
- \r
- if (m == killer1)\r
- hs = HistoryMax + 2;\r
- else if (m == killer2)\r
- hs = HistoryMax + 1;\r
- else\r
- hs = H.move_ordering_score(pos.piece_on(move_from(m)), m);\r
- \r
- // Ensure moves in history are always sorted as first\r
- if (hs > 0)\r
- hs += 1000;\r
- \r
- moves[i].score = hs + pos.mg_pst_delta(m);\r
+ // First score by history, when no history is available then use
+ // piece/square tables values. This seems to be better then a
+ // random choice when we don't have an history for any move.
- Move m = moves[i].move;
++ Move m;
++ int hs;
+
+ for (int i = 0; i < numOfMoves; i++)
+ {
- moves[i].score = HistoryMax + 2;
++ m = moves[i].move;
++
+ if (m == killer1)
- moves[i].score = HistoryMax + 1;
++ hs = HistoryMax + 2;
+ else if (m == killer2)
- moves[i].score = H.move_ordering_score(pos.piece_on(move_from(m)), m);
++ hs = HistoryMax + 1;
+ else
- if (moves[i].score > 0)
- moves[i].score += 1000;
++ hs = H.move_ordering_score(pos.piece_on(move_from(m)), m);
+
+ // Ensure moves in history are always sorted as first
- moves[i].score += pos.mg_pst_delta(moves[i].move);
++ if (hs > 0)
++ hs += 1000;
+
++ moves[i].score = hs + pos.mg_pst_delta(m);
}
}
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
++<<<<<<< HEAD:src/movepick.h
+
++=======
+
++>>>>>>> d3600c39a745179ed6b094b305d0645e83a1ee86:src/movepick.h
Stockfish is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
--
++
Stockfish is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
--
++
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#if defined(_MSC_VER)
// Forcing value to bool 'true' or 'false' (performance warning)
--#pragma warning(disable: 4800) \r
--\r
++#pragma warning(disable: 4800)
++
#endif
////
////
/// FEN string for the initial position:
--const std::string StartPosition =
++const std::string StartPosition =
"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
/// Maximum number of plies per game (220 should be enough, because the
/// Castle rights, encoded as bit fields:
enum CastleRights {
-- NO_CASTLES = 0,
++ NO_CASTLES = 0,
WHITE_OO = 1,
-- BLACK_OO = 2,
++ BLACK_OO = 2,
WHITE_OOO = 4,
BLACK_OOO = 8,
ALL_CASTLES = 15
/// The position data structure. A position consists of the following data:
--///
++///
/// * For each piece type, a bitboard representing the squares occupied
/// by pieces of that type.
/// * For each color, a bitboard representing the squares occupiecd by
// Reset the gamePly variable to 0
void reset_game_ply();
--
++
// Position consistency check, for debugging
bool is_ok(int* failedStep = NULL) const;
// Piece counts
int pieceCount[2][8]; // [color][pieceType]
--
++
// Piece lists
Square pieceList[2][8][16]; // [color][pieceType][index]
int index[64];
inline bool Position::square_is_weak(Square s, Color c) const {
return !(pawns(c) & outpost_mask(opposite_color(c), s));
}
--
++
inline Key Position::get_key() const {
return key;
}
static const Value EndgameLimit = 4 * RookValueMidgame - Value(325);
Value npm = non_pawn_material(WHITE) + non_pawn_material(BLACK);
--
++
if (npm >= MidgameLimit)
return PHASE_MIDGAME;
else if(npm <= EndgameLimit)
inline bool Position::opposite_colored_bishops() const {
return piece_count(WHITE, BISHOP) == 1
-- && piece_count(BLACK, BISHOP) == 1
++ && piece_count(BLACK, BISHOP) == 1
&& square_color(piece_list(WHITE, BISHOP, 0)) != square_color(piece_list(BLACK, BISHOP, 0));
}
return pawns(c) & relative_rank_bb(c, RANK_7);
}
--
++
#endif // !defined(POSITION_H_INCLUDED)
projects / stockfish / commitdiff