+ // evaluate_unstoppable_pawns() evaluates the unstoppable passed pawns for both sides
+
+ template<bool HasPopCnt>
+ Score evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei) {
+
+ const BitCountType Max15 = HasPopCnt ? CNT_POPCNT : CpuIs64Bit ? CNT64_MAX15 : CNT32_MAX15;
+
+ Bitboard b1, b2, queeningPath, candidates, supBB, sacBB;
+ Square s1, s2, queeningSquare, supSq, sacSq;
+ Color c, winnerSide, loserSide;
+ bool pathDefended, opposed;
+ int pliesToGo, movesToGo, oppMovesToGo;
+ int pliesToQueen[] = { 256, 256 };
+
+ // Step 1. Hunt for unstoppable pawns. If we find at least one, record how many plies
+ // are required for promotion
+ for (c = WHITE; c <= BLACK; c++)
+ {
+ // Skip if other side has non-pawn pieces
+ if (pos.non_pawn_material(opposite_color(c)))
+ continue;
+
+ b1 = ei.pi->passed_pawns(c);
+
+ while (b1)
+ {
+ s1 = pop_1st_bit(&b1);
+ queeningSquare = relative_square(c, make_square(square_file(s1), RANK_8));
+ queeningPath = squares_in_front_of(c, s1);
+
+ // Compute plies from queening and check direct advancement
+ movesToGo = rank_distance(s1, queeningSquare) - int(relative_rank(c, s1) == RANK_2);
+ oppMovesToGo = square_distance(pos.king_square(opposite_color(c)), queeningSquare) - int(c != pos.side_to_move());
+ pathDefended = ((ei.attackedBy[c][0] & queeningPath) == queeningPath);
+
+ if (movesToGo >= oppMovesToGo && !pathDefended)
+ continue;
+
+ // Opponent king cannot block because path is defended and position
+ // is not in check. So only friendly pieces can be blockers.
+ assert(!pos.in_check());
+ assert(queeningPath & pos.occupied_squares() == queeningPath & pos.pieces_of_color(c));
+
+ // Add moves needed to free the path from friendly pieces and retest condition
+ movesToGo += count_1s<Max15>(queeningPath & pos.pieces_of_color(c));
+
+ if (movesToGo >= oppMovesToGo && !pathDefended)
+ continue;
+
+ pliesToGo = 2 * movesToGo - int(c == pos.side_to_move());
+
+ if (pliesToGo < pliesToQueen[c])
+ pliesToQueen[c] = pliesToGo;
+ }
+ }
+
+ // Step 2. If either side cannot promote at least three plies before the other side then situation
+ // becomes too complex and we give up. Otherwise we determine the possibly "winning side"
+ if (abs(pliesToQueen[WHITE] - pliesToQueen[BLACK]) < 3)
+ return SCORE_ZERO;
+
+ winnerSide = (pliesToQueen[WHITE] < pliesToQueen[BLACK] ? WHITE : BLACK);
+ loserSide = opposite_color(winnerSide);
+
+ // Step 3. Can the losing side possibly create a new passed pawn and thus prevent the loss?
+ // We collect the potential candidates in potentialBB.
+ b1 = candidates = pos.pieces(PAWN, loserSide);
+
+ while (b1)
+ {
+ s1 = pop_1st_bit(&b1);
+
+ // Compute plies from queening
+ queeningSquare = relative_square(loserSide, make_square(square_file(s1), RANK_8));
+ movesToGo = rank_distance(s1, queeningSquare) - int(relative_rank(loserSide, s1) == RANK_2);
+ pliesToGo = 2 * movesToGo - int(loserSide == pos.side_to_move());
+
+ // Check if (without even considering any obstacles) we're too far away or doubled
+ if ( pliesToQueen[winnerSide] + 3 <= pliesToGo
+ || (squares_in_front_of(loserSide, s1) & pos.pieces(PAWN, loserSide)))
+ clear_bit(&candidates, s1);
+ }
+
+ // If any candidate is already a passed pawn it _may_ promote in time. We give up.
+ if (candidates & ei.pi->passed_pawns(loserSide))
+ return SCORE_ZERO;
+
+ // Step 4. Check new passed pawn creation through king capturing and sacrifices
+ b1 = candidates;
+
+ while (b1)
+ {
+ s1 = pop_1st_bit(&b1);
+
+ // Compute plies from queening
+ queeningSquare = relative_square(loserSide, make_square(square_file(s1), RANK_8));
+ movesToGo = rank_distance(s1, queeningSquare) - int(relative_rank(loserSide, s1) == RANK_2);
+ pliesToGo = 2 * movesToGo - int(loserSide == pos.side_to_move());
+
+ // Generate list of obstacles
+ opposed = squares_in_front_of(loserSide, s1) & pos.pieces(PAWN, winnerSide);
+ b2 = passed_pawn_mask(loserSide, s1) & pos.pieces(PAWN, winnerSide);
+
+ assert(b2);
+
+ // How many plies does it take to remove all the obstacles?
+ int sacptg = 0;
+ int realObsCount = 0;
+ int minKingDist = 256;
+ int kingptg = 256;
+
+ while (b2)
+ {
+ s2 = pop_1st_bit(&b2);
+ movesToGo = 256;
+
+ // Check pawns that can give support to overcome obstacle, for instance
+ // black pawns: a4, b4 white: b2 then pawn in b4 is giving support.
+ if (!opposed && square_file(s1) != square_file(s2))
+ {
+ supBB = in_front_bb(winnerSide, s2 + pawn_push(winnerSide)) & neighboring_files_bb(s1) & candidates;
+
+ while (supBB) // This while-loop could be replaced with supSq = LSB/MSB(supBB) (depending on color)
+ {
+ supSq = pop_1st_bit(&supBB);
+ movesToGo = Min(movesToGo, square_distance(s2, supSq) - 2);
+ }
+ }
+
+ // Check pawns that can be sacrificed
+ sacBB = passed_pawn_mask(winnerSide, s2) & neighboring_files_bb(s2) & candidates & ~(1ULL << s1);
+
+ while (sacBB) // This while-loop could be replaced with sacSq = LSB/MSB(sacBB) (depending on color)
+ {
+ sacSq = pop_1st_bit(&sacBB);
+ movesToGo = Min(movesToGo, square_distance(s2, sacSq) - 2);
+ }
+
+ // Good, obstacle can be destroyed with an immediate pawn sacrifice,
+ // it's not a real obstacle and we have nothing to add to pliesToGo.
+ if (movesToGo <= 0)
+ continue;
+
+ // Plies needed to sacrifice the pawn
+ sacptg += movesToGo * 2;
+ realObsCount++;
+
+ // Plies needed for the king to capture opposing pawn
+ minKingDist = Min(minKingDist, square_distance(pos.king_square(loserSide), s2));
+ kingptg = (minKingDist + realObsCount) * 2;
+ }
+
+ // Check if pawn sacrifice plan _may_ save the day
+ if (pliesToQueen[winnerSide] + 3 > pliesToGo + sacptg)
+ return SCORE_ZERO;
+
+ // Check if king capture plan _may_ save the day (contains some false positives)
+ if (pliesToQueen[winnerSide] + 3 > pliesToGo + kingptg)
+ return SCORE_ZERO;
+ }
+
+ // Winning pawn is unstoppable and will promote as first, return big score
+ Score score = make_score(0, (Value) 0x500 - 0x20 * pliesToQueen[winnerSide]);
+ return winnerSide == WHITE ? score : -score;
+ }
+
+