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/>.
*/
KQKREvaluationFunction EvaluateKQKR = KQKREvaluationFunction(WHITE);
KQKREvaluationFunction EvaluateKRKQ = KQKREvaluationFunction(BLACK);
+// KBB vs KN:
+KBBKNEvaluationFunction EvaluateKBBKN = KBBKNEvaluationFunction(WHITE);
+KBBKNEvaluationFunction EvaluateKNKBB = KBBKNEvaluationFunction(BLACK);
+
+// K and two minors vs K and one or two minors:
+KmmKmEvaluationFunction EvaluateKmmKm = KmmKmEvaluationFunction(WHITE);
+
/// Scaling functions
const int KRKNKingKnightDistancePenalty[8] = { 0, 0, 4, 10, 20, 32, 48, 70 };
// Various inline functions for accessing the above arrays:
-
+
inline Value mate_table(Square s) {
return Value(MateTable[s]);
}
int probe_kpk(Square wksq, Square wpsq, Square bksq, Color stm);
}
-
+
////
//// Functions
KRKBEvaluationFunction::KRKBEvaluationFunction(Color c) : EndgameEvaluationFunction(c) { }
KRKNEvaluationFunction::KRKNEvaluationFunction(Color c) : EndgameEvaluationFunction(c) { }
KQKREvaluationFunction::KQKREvaluationFunction(Color c) : EndgameEvaluationFunction(c) { }
+KBBKNEvaluationFunction::KBBKNEvaluationFunction(Color c) : EndgameEvaluationFunction(c) { }
+KmmKmEvaluationFunction::KmmKmEvaluationFunction(Color c) : EndgameEvaluationFunction(c) { }
ScalingFunction::ScalingFunction(Color c) {
/// Mate with KBN vs K. This is similar to KX vs K, but we have to drive the
/// defending king towards a corner square of the right color.
-
+
Value KBNKEvaluationFunction::apply(const Position &pos) {
assert(pos.non_pawn_material(weakerSide) == Value(0));
assert(pos.non_pawn_material(weakerSide) == Value(0));
assert(pos.piece_count(strongerSide, PAWN) == 1);
assert(pos.piece_count(weakerSide, PAWN) == 0);
-
+
Square wksq, bksq, wpsq;
Color stm;
Square winnerKSq = pos.king_square(strongerSide);
Square loserKSq = pos.king_square(weakerSide);
-
+
Value result = QueenValueEndgame - RookValueEndgame +
mate_table(loserKSq) + distance_bonus(square_distance(winnerKSq, loserKSq));
}
+Value KBBKNEvaluationFunction::apply(const Position &pos) {
+ assert(pos.piece_count(strongerSide, BISHOP) == 2);
+ assert(pos.non_pawn_material(strongerSide) == 2*BishopValueMidgame);
+ assert(pos.piece_count(weakerSide, KNIGHT) == 1);
+ assert(pos.non_pawn_material(weakerSide) == KnightValueMidgame);
+ assert(pos.pawns() == EmptyBoardBB);
+
+ Value result = BishopValueEndgame;
+ Square wksq = pos.king_square(strongerSide);
+ Square bksq = pos.king_square(weakerSide);
+ Square nsq = pos.piece_list(weakerSide, KNIGHT, 0);
+
+ // Bonus for attacking king close to defending king
+ result += distance_bonus(square_distance(wksq, bksq));
+
+ // Bonus for driving the defending king and knight apart
+ result += Value(square_distance(bksq, nsq) * 32);
+
+ // Bonus for restricting the knight's mobility
+ result += Value((8 - count_1s_max_15(pos.piece_attacks<KNIGHT>(nsq))) * 8);
+
+ return (strongerSide == pos.side_to_move())? result : -result;
+}
+
+
+Value KmmKmEvaluationFunction::apply(const Position &pos) {
+ return Value(0);
+}
+
+
/// KBPKScalingFunction scales endgames where the stronger side has king,
/// bishop and one or more pawns. It checks for draws with rook pawns and a
/// bishop of the wrong color. If such a draw is detected, ScaleFactor(0) is
- (8 * square_distance(wpsq, queeningSq) +
2 * square_distance(wksq, queeningSq)));
+ // If the pawn is not far advanced, and the defending king is somewhere in
+ // the pawn's path, it's probably a draw:
+ if(r <= RANK_4 && bksq > wpsq) {
+ if(square_file(bksq) == square_file(wpsq))
+ return ScaleFactor(10);
+ if(abs(square_file(bksq) - square_file(wpsq)) == 1
+ && square_distance(wksq, bksq) > 2)
+ return ScaleFactor(24 - 2 * square_distance(wksq, bksq));
+ }
+
return SCALE_FACTOR_NONE;
}
// Case 2: Opposite colored bishops.
if(square_color(strongerBishopSq) != square_color(weakerBishopSq)) {
-
+
// We assume that the position is drawn in the following three situations:
- //
+ //
// a. The pawn is on rank 5 or further back.
// b. The defending king is somewhere in the pawn's path.
// c. The defending bishop attacks some square along the pawn's path,
//
// These rules are probably not perfect, but in practice they work
// reasonably well.
-
+
if(relative_rank(strongerSide, pawnSq) <= RANK_5)
return ScaleFactor(0);
else {
Square pawnSq = pos.piece_list(strongerSide, PAWN, 0);
Square strongerBishopSq = pos.piece_list(strongerSide, BISHOP, 0);
Square weakerKingSq = pos.king_square(weakerSide);
-
+
if(square_file(weakerKingSq) == square_file(pawnSq)
&& relative_rank(strongerSide, pawnSq) < relative_rank(strongerSide, weakerKingSq)
&& (square_color(weakerKingSq) != square_color(strongerBishopSq)
int probe_kpk(Square wksq, Square wpsq, Square bksq, Color stm) {
int wp = int(square_file(wpsq)) + (int(square_rank(wpsq)) - 1) * 4;
int index = int(stm) + 2*int(bksq) + 128*int(wksq) + 8192*wp;
-
+
assert(index >= 0 && index < 24576*8);
return KPKBitbase[index/8] & (1 << (index&7));
}
-
+
}
projects / stockfish / blobdiff