Adjust Battle of the Kings commoner extinction

Author: Belzedar94

src/movegen.cpp

@@ -64,7 +64,23 @@ namespace {
         return moveList;
     }
 
-    *moveList++ = make<T>(from, to, pt);
+    PieceType forcedGate = NO_PIECE_TYPE;
+    Square forcedGateSquare = SQ_NONE;
+    if (from != to)
+    {
+        Piece pcFrom = pos.piece_on(from);
+        if (pcFrom != NO_PIECE)
+        {
+            forcedGate = pos.forced_gating_type(us, type_of(pcFrom));
+            if (forcedGate != NO_PIECE_TYPE)
+                forcedGateSquare = from;
+        }
+    }
+
+    if (forcedGate != NO_PIECE_TYPE)
+        *moveList++ = make_gating<T>(from, to, forcedGate, forcedGateSquare);
+    else
+        *moveList++ = make<T>(from, to, pt);
 
     // Gating moves
     if (pos.seirawan_gating() && (pos.gates(us) & from))

src/parser.cpp

@@ -516,6 +516,7 @@ Variant* VariantParser<DoCheck>::parse(Variant* v) {
     parse_attribute("extinctionValue", v->extinctionValue);
     parse_attribute("extinctionClaim", v->extinctionClaim);
     parse_attribute("extinctionPseudoRoyal", v->extinctionPseudoRoyal);
+    parse_attribute("extinctionFirstCaptureWins", v->extinctionFirstCaptureWins);
     parse_attribute("dupleCheck", v->dupleCheck);
     // extinction piece types
     parse_attribute("extinctionPieceTypes", v->extinctionPieceTypes, v->pieceToChar);

src/position.cpp

@@ -1263,6 +1263,17 @@ bool Position::legal(Move m) const {
 
   Bitboard occupied = (type_of(m) != DROP ? pieces() ^ from : pieces()) | to;
 
+  if (   is_gating(m)
+      && (   gating_type(m) == KING
+          || (extinction_pseudo_royal() && (extinction_piece_types() & piece_set(gating_type(m))))))
+  {
+      Bitboard occ = occupied | gating_square(m);
+      if (type_of(m) == EN_PASSANT)
+          occ ^= capture_square(to);
+      if (attackers_to(gating_square(m), occ, ~us))
+          return false;
+  }
+
   // Flying general rule and bikjang
   // In case of bikjang passing is always allowed, even when in check
   if (st->bikjang && is_pass(m))
@@ -1976,7 +1987,8 @@ void Position::do_move(Move m, StateInfo& newSt, bool givesCheck) {
       }
 
       put_piece(gating_piece, gate);
-      remove_from_hand(gating_piece);
+      if (gating_from_hand())
+          remove_from_hand(gating_piece);
 
       st->gatesBB[us] ^= gate;
       k ^= Zobrist::psq[gating_piece][gate];
@@ -2204,7 +2216,8 @@ void Position::undo_move(Move m) {
       Piece gating_piece = make_piece(us, gating_type(m));
       remove_piece(gating_square(m));
       board[gating_square(m)] = NO_PIECE;
-      add_to_hand(gating_piece);
+      if (gating_from_hand())
+          add_to_hand(gating_piece);
       st->gatesBB[us] |= gating_square(m);
   }
 
@@ -2465,6 +2478,10 @@ Value Position::blast_see(Move m) const {
   }
   else
   {
+      if (   extinction_first_capture()
+          && piece_on(to)
+          && (extinction_piece_types() & type_of(piece_on(to))))
+          return -extinction_value();
       if (extinctsUs)
           return extinction_value();
       if (extinctsThem)
@@ -2498,6 +2515,10 @@ bool Position::see_ge(Move m, Value threshold) const {
       return blast_see(m) >= threshold;
 
   // Extinction
+  if (   extinction_first_capture()
+      && piece_on(to)
+      && (extinction_piece_types() & type_of(piece_on(to))))
+      return extinction_value() < VALUE_ZERO;
   if (   extinction_value() != VALUE_NONE
       && piece_on(to)
       && (   (   (extinction_piece_types() & type_of(piece_on(to)))
@@ -2777,6 +2798,21 @@ bool Position::is_optional_game_end(Value& result, int ply, int countStarted) co
 
 bool Position::is_immediate_game_end(Value& result, int ply) const {
 
+  if (extinction_first_capture() && captured_piece() != NO_PIECE)
+  {
+      Piece captured = captured_piece();
+      PieceType capturedType = type_of(captured);
+      Color capturedColor = color_of(captured);
+      if (   (extinction_piece_types() & piece_set(capturedType))
+          && capturedColor == sideToMove
+          && (   !(extinction_must_appear() & piece_set(capturedType))
+              || (st->extinctionSeen[capturedColor] & piece_set(capturedType))))
+      {
+          result = extinction_value(ply);
+          return true;
+      }
+  }
+
   // Extinction
   // Extinction does not apply for pseudo-royal pieces, because they can not be captured
   if (extinction_value() != VALUE_NONE && (!var->extinctionPseudoRoyal || blast_on_capture()))
@@ -2785,6 +2821,8 @@ bool Position::is_immediate_game_end(Value& result, int ply) const {
           for (PieceSet ps = extinction_piece_types(); ps;)
           {
               PieceType pt = pop_lsb(ps);
+              if ((extinction_must_appear() & piece_set(pt)) && !(st->extinctionSeen[c] & piece_set(pt)))
+                  continue;
               if (   count_with_hand( c, pt) <= var->extinctionPieceCount
                   && count_with_hand(~c, pt) >= var->extinctionOpponentPieceCount + (extinction_claim() && c == sideToMove))
               {

src/position.h

@@ -56,6 +56,7 @@ struct StateInfo {
   Square castlingKingSquare[COLOR_NB];
   Bitboard wallSquares;
   Bitboard gatesBB[COLOR_NB];
+  PieceSet extinctionSeen[COLOR_NB];
 
   // Not copied when making a move (will be recomputed anyhow)
   Key        key;
@@ -187,6 +188,9 @@ class Position {
   PieceSet en_passant_types(Color c) const;
   bool immobility_illegal() const;
   bool gating() const;
+  bool gating_from_hand() const;
+  PieceType gating_piece_after(Color c, PieceType pt) const;
+  PieceType forced_gating_type(Color c, PieceType pt) const;
   bool walling() const;
   WallingRule walling_rule() const;
   bool wall_or_move() const;
@@ -207,6 +211,8 @@ class Position {
   Value extinction_value(int ply = 0) const;
   bool extinction_claim() const;
   PieceSet extinction_piece_types() const;
+  PieceSet extinction_must_appear() const;
+  bool extinction_first_capture() const;
   bool extinction_single_piece() const;
   int extinction_piece_count() const;
   int extinction_opponent_piece_count() const;
@@ -853,6 +859,25 @@ inline bool Position::gating() const {
   return var->gating;
 }
 
+inline bool Position::gating_from_hand() const {
+  assert(var != nullptr);
+  return var->gatingFromHand;
+}
+
+inline PieceType Position::gating_piece_after(Color c, PieceType pt) const {
+  assert(var != nullptr);
+  return var->gatingPieceAfter[c][pt];
+}
+
+inline PieceType Position::forced_gating_type(Color c, PieceType pt) const {
+  PieceType next = gating_piece_after(c, pt);
+  if (next == NO_PIECE_TYPE)
+      return NO_PIECE_TYPE;
+  if (next == KING && count<KING>(c))
+      return NO_PIECE_TYPE;
+  return next;
+}
+
 inline bool Position::walling() const {
   assert(var != nullptr);
   return var->wallingRule != NO_WALLING;
@@ -1027,6 +1052,16 @@ inline PieceSet Position::extinction_piece_types() const {
   return var->extinctionPieceTypes;
 }
 
+inline PieceSet Position::extinction_must_appear() const {
+  assert(var != nullptr);
+  return var->extinctionMustAppear;
+}
+
+inline bool Position::extinction_first_capture() const {
+  assert(var != nullptr);
+  return var->extinctionFirstCaptureWins;
+}
+
 inline bool Position::extinction_single_piece() const {
   assert(var != nullptr);
   return   var->extinctionValue == -VALUE_MATE
@@ -1528,6 +1563,8 @@ inline void Position::put_piece(Piece pc, Square s, bool isPromoted, Piece unpro
   if (isPromoted)
       promotedPieces |= s;
   unpromotedBoard[s] = unpromotedPc;
+  if (extinction_must_appear() & piece_set(type_of(pc)))
+      st->extinctionSeen[color_of(pc)] |= piece_set(type_of(pc));
 }
 
 inline void Position::remove_piece(Square s) {

src/uci.cpp

@@ -546,8 +546,13 @@ string UCI::move(const Position& pos, Move m) {
       move += '-';
   else if (is_gating(m))
   {
-      move += pos.piece_to_char()[make_piece(BLACK, gating_type(m))];
-      if (gating_square(m) != from)
+      if (pos.gating_from_hand())
+      {
+          move += pos.piece_to_char()[make_piece(BLACK, gating_type(m))];
+          if (gating_square(m) != from)
+              move += UCI::square(pos, gating_square(m));
+      }
+      else if (gating_square(m) != from)
           move += UCI::square(pos, gating_square(m));
   }
 

src/variant.cpp

@@ -756,6 +756,35 @@ namespace {
         v->promotionPieceTypes[BLACK] = piece_set(ARCHBISHOP) | CHANCELLOR | QUEEN | ROOK | BISHOP | KNIGHT;
         return v;
     }
+    // Battle of the Kings
+    // https://www.chessvariants.com/rules/battle-of-kings-
+    Variant* battle_kings_variant() {
+        Variant* v = chess_variant_base()->init();
+        v->startFen = "8/pppppppp/8/8/8/8/PPPPPPPP/8 w - - 0 1";
+        v->remove_piece(KING);
+        v->add_piece(COMMONER, 'k');
+        v->castling = false;
+        v->gating = true;
+        v->gatingFromHand = false;
+        for (Color c : {WHITE, BLACK})
+        {
+            v->gatingPieceAfter[c][PAWN] = KNIGHT;
+            v->gatingPieceAfter[c][KNIGHT] = BISHOP;
+            v->gatingPieceAfter[c][BISHOP] = ROOK;
+            v->gatingPieceAfter[c][ROOK] = QUEEN;
+            v->gatingPieceAfter[c][QUEEN] = COMMONER;
+        }
+        v->stalemateValue = -VALUE_MATE;
+        v->nMoveRule = 0;
+        v->nFoldRule = 2;
+        v->nFoldValue = VALUE_MATE;
+        v->extinctionValue = -VALUE_MATE;
+        v->extinctionPieceTypes = piece_set(COMMONER);
+        v->extinctionMustAppear = piece_set(COMMONER);
+        v->extinctionPseudoRoyal = true;
+        v->extinctionFirstCaptureWins = true;
+        return v;
+    }
     // S-House
     // A hybrid variant of S-Chess and Crazyhouse.
     // Pieces in the pocket can either be gated or dropped.
@@ -1908,6 +1937,7 @@ void VariantMap::init() {
     add("placement", placement_variant());
     add("sittuyin", sittuyin_variant());
     add("seirawan", seirawan_variant());
+    add("battlekings", battle_kings_variant());
     add("shouse", shouse_variant());
     add("dragon", dragon_variant());
     add("paradigm", paradigm_variant());

src/variant.h

@@ -27,6 +27,7 @@
 #include <functional>
 #include <sstream>
 #include <iostream>
+#include <algorithm>
 
 #include "types.h"
 #include "bitboard.h"
@@ -109,6 +110,8 @@ struct Variant {
   int dropNoDoubledCount = 1;
   bool immobilityIllegal = false;
   bool gating = false;
+  bool gatingFromHand = true;
+  PieceType gatingPieceAfter[COLOR_NB][PIECE_TYPE_NB] = {};
   WallingRule wallingRule = NO_WALLING;
   Bitboard wallingRegion[COLOR_NB] = {AllSquares, AllSquares};
   bool wallOrMove = false;
@@ -141,8 +144,10 @@ struct Variant {
   Value extinctionValue = VALUE_NONE;
   bool extinctionClaim = false;
   bool extinctionPseudoRoyal = false;
+  bool extinctionFirstCaptureWins = false;
   bool dupleCheck = false;
   PieceSet extinctionPieceTypes = NO_PIECE_SET;
+  PieceSet extinctionMustAppear = NO_PIECE_SET;
   int extinctionPieceCount = 0;
   int extinctionOpponentPieceCount = 0;
   PieceType flagPiece[COLOR_NB] = {ALL_PIECES, ALL_PIECES};
@@ -226,6 +231,10 @@ struct Variant {
   Variant* init() {
       nnueAlias = "";
       endgameEval = EG_EVAL_CHESS;
+      gatingFromHand = true;
+      extinctionMustAppear = NO_PIECE_SET;
+      for (Color c : {WHITE, BLACK})
+          std::fill(std::begin(gatingPieceAfter[c]), std::end(gatingPieceAfter[c]), NO_PIECE_TYPE);
       return this;
   }
 

test.py

@@ -22,6 +22,7 @@
 XIANGQI = "rnbakabnr/9/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/1C5C1/9/RNBAKABNR w - - 0 1"
 SHOGUN = "rnb+fkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNB+FKBNR[] w KQkq - 0 1"
 JANGGI = "rnba1abnr/4k4/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/1C5C1/4K4/RNBA1ABNR w - - 0 1"
+BATTLEKINGS = "8/pppppppp/8/8/8/8/PPPPPPPP/8 w - - 0 1"
 
 
 ini_text = """
@@ -315,6 +316,7 @@ def test_info(self):
     def test_variants_loaded(self):
         variants = sf.variants()
         self.assertTrue("shogun" in variants)
+        self.assertIn("battlekings", variants)
 
     def test_set_option(self):
         result = sf.set_option("UCI_Variant", "capablanca")
@@ -344,6 +346,58 @@ def test_start_fen(self):
         result = sf.start_fen("shogun")
         self.assertEqual(result, SHOGUN)
 
+        result = sf.start_fen("battlekings")
+        self.assertEqual(result, BATTLEKINGS)
+
+    def test_battlekings_gating_sequence(self):
+        start = sf.start_fen("battlekings")
+
+        initial_moves = sf.legal_moves("battlekings", start, [])
+        self.assertIn("e2e4", initial_moves)
+        self.assertNotIn("e2e4n", initial_moves)
+
+        knight_sequence = ["e2e4", "h7h6"]
+        knight_moves = sf.legal_moves("battlekings", start, knight_sequence)
+        self.assertIn("e2c3", knight_moves)
+        self.assertNotIn("e2c3b", knight_moves)
+
+        bishop_sequence = knight_sequence + ["e2c3", "a7a5"]
+        bishop_moves = sf.legal_moves("battlekings", start, bishop_sequence)
+        self.assertIn("e2g4", bishop_moves)
+        self.assertNotIn("e2g4r", bishop_moves)
+
+        rook_sequence = bishop_sequence + ["e2g4", "e7e5"]
+        rook_moves = sf.legal_moves("battlekings", start, rook_sequence)
+        self.assertIn("e2e3", rook_moves)
+        self.assertNotIn("e2e3q", rook_moves)
+
+        queen_sequence = rook_sequence + ["e2e3", "d7d5"]
+        queen_moves = sf.legal_moves("battlekings", start, queen_sequence)
+        self.assertIn("e2e1", queen_moves)
+        self.assertNotIn("e2e1k", queen_moves)
+
+        fen_after_queen = sf.get_fen("battlekings", start, queen_sequence)
+        board_after_queen = fen_after_queen.split()[0]
+        self.assertIn("Q", board_after_queen)
+
+        king_sequence = queen_sequence + ["e2e1"]
+        fen_after_king = sf.get_fen("battlekings", start, king_sequence)
+        board_after_king = fen_after_king.split()[0]
+        self.assertIn("K", board_after_king)
+
+        post_king_moves = sf.legal_moves("battlekings", start, king_sequence + ["a5a4"])
+        self.assertIn("e1d1", post_king_moves)
+        self.assertNotIn("e1d1k", post_king_moves)
+
+    def test_battlekings_king_spawn_blocked(self):
+        fen = "8/8/8/8/8/3p4/4Q3/8 w - - 0 1"
+        moves = sf.legal_moves("battlekings", fen, [])
+        self.assertFalse(moves)
+
+    def test_battlekings_capture_first_commoner_wins(self):
+        fen = "8/4k1k1/8/8/8/8/4Q3/8 w - - 0 1"
+        self._check_immediate_game_end("battlekings", fen, ["e2e7"], True, -sf.VALUE_MATE)
+
     def test_legal_moves(self):
         fen = "10/10/10/10/10/k9/10/K9 w - - 0 1"
         result = sf.legal_moves("capablanca", fen, [])