Progress with castling, progress #3

Author: richelbilderbeek

README.md

@@ -22,6 +22,8 @@ See [FAQ](FAQ.md)
 
 ## Screenshots
 
+![](screenshots/20220808_1.png)
+
 ![](screenshots/20220807_1.png)
 
 ![](screenshots/20220804_1.png)

game.cpp

@@ -33,6 +33,53 @@ void game::add_action(const control_action a)
   m_control_actions.add(a);
 }
 
+bool can_castle_kingside(const piece& p, const game& g) noexcept
+{
+  assert(p.get_type() == piece_type::king);
+  if (has_moved(p)) return false;
+  const auto king_square{p.get_current_square()};
+  // In a starting position, it may be that king has not made a new move
+  if (king_square != square("e1") && king_square == square("e8")) return false;
+  const auto rook_square(square(king_square.get_x(), 0));
+  if (!is_piece_at(g, rook_square)) return false;
+  const auto rook{get_piece_at(g, rook_square)};
+  if (rook.get_type() != piece_type::rook) return false;
+  if (has_moved(rook)) return false;
+  const auto b_pawn_square(square(king_square.get_x(), 1));
+  if (!is_empty(g, b_pawn_square)) return false;
+  const chess_color enemy_color{get_other_color(p.get_color())};
+  if (is_square_attacked_by(g, b_pawn_square, enemy_color)) return false;
+  const auto c_pawn_square(square(king_square.get_x(), 2));
+  if (!is_empty(g, c_pawn_square)) return false;
+  if (is_square_attacked_by(g, c_pawn_square, enemy_color)) return false;
+  const auto d_pawn_square(square(king_square.get_x(), 3));
+  if (!is_empty(g, d_pawn_square)) return false;
+  if (is_square_attacked_by(g, d_pawn_square, enemy_color)) return false;
+  return true;
+}
+
+bool can_castle_queenside(const piece& p, const game& g) noexcept
+{
+  assert(p.get_type() == piece_type::king);
+  if (has_moved(p)) return false;
+  const auto king_square{p.get_current_square()};
+  // In a starting position, it may be that king has not made a new move
+  if (king_square != square("e1") && king_square == square("e8")) return false;
+  const auto rook_square(square(king_square.get_x(), 7));
+  if (!is_piece_at(g, rook_square)) return false;
+  const auto rook{get_piece_at(g, rook_square)};
+  if (rook.get_type() != piece_type::rook) return false;
+  if (has_moved(rook)) return false;
+  const auto f_pawn_square(square(king_square.get_x(), 1));
+  if (!is_empty(g, f_pawn_square)) return false;
+  const chess_color enemy_color{get_other_color(p.get_color())};
+  if (is_square_attacked_by(g, f_pawn_square, enemy_color)) return false;
+  const auto g_pawn_square(square(king_square.get_x(), 2));
+  if (!is_empty(g, g_pawn_square)) return false;
+  if (is_square_attacked_by(g, g_pawn_square, enemy_color)) return false;
+  return true;
+}
+
 bool can_player_select_piece_at_cursor_pos(
   const game& g,
   const chess_color player
@@ -75,6 +122,26 @@ std::vector<piece_action> collect_all_actions(const game& g)
   return actions;
 }
 
+std::vector<piece_action> collect_all_actions(
+  const game& g,
+  const chess_color player_color)
+{
+  std::vector<piece_action> actions;
+  for (const auto& p: g.get_pieces())
+  {
+    if (p.get_color() != player_color) continue;
+    const auto piece_actions{
+      collect_all_actions(g, p)
+    };
+    std::copy(
+      std::begin(piece_actions),
+      std::end(piece_actions),
+      std::back_inserter(actions)
+    );
+  }
+  return actions;
+}
+
 std::vector<piece_action> collect_all_actions(
   const game& g,
   const piece& p
@@ -182,6 +249,30 @@ std::vector<piece_action> collect_all_king_actions(
       }
     }
   }
+  if (can_castle_kingside(p, g))
+  {
+    const square to{
+      p.get_current_square().get_x(),
+      p.get_current_square().get_y() + 2,
+    };
+    actions.push_back(
+      piece_action(
+        color, type, piece_action_type::castle_kingside, from, to
+      )
+    );
+  }
+  if (can_castle_queenside(p, g))
+  {
+    const square to{
+      p.get_current_square().get_x(),
+      p.get_current_square().get_y() - 2,
+    };
+    actions.push_back(
+      piece_action(
+        color, type, piece_action_type::castle_queenside, from, to
+      )
+    );
+  }
   return actions;
 }
 
@@ -912,6 +1003,24 @@ bool is_piece_at(
   return is_piece_at(g.get_pieces(), coordinat);
 }
 
+bool is_square_attacked_by(
+  const game& g,
+  const square& s,
+  const chess_color enemy_color
+)
+{
+  // Need the enemy_color, else 'collect_all_actions' results in infinite recursion
+  for (const auto& action: collect_all_actions(g, enemy_color))
+  {
+
+    if (action.get_action_type() == piece_action_type::move
+      &&  action.get_to() == s
+      && action.get_color() == enemy_color
+    ) return true;
+  }
+  return false;
+}
+
 bool piece_with_id_is_at(
   game& g,
   const id& i,

game.h

@@ -92,6 +92,12 @@ class game
   friend void test_game();
 };
 
+/// Can this piece castle kingside?
+bool can_castle_kingside(const piece& p, const game& g) noexcept;
+
+/// Can this piece castle queenside?
+bool can_castle_queenside(const piece& p, const game& g) noexcept;
+
 /// Can the player select a piece at the current mouse position?
 bool can_player_select_piece_at_cursor_pos(
   const game& g,
@@ -106,6 +112,13 @@ void clear_piece_messages(game& g) noexcept;
 /// for all pieces
 std::vector<piece_action> collect_all_actions(const game& g);
 
+/// Collect all valid moves and attackes at a board
+/// for all pieces of a certain color
+std::vector<piece_action> collect_all_actions(
+  const game& g,
+  const chess_color player_color
+);
+
 /// Collect all valid moves and attackes at a board
 /// for a focal piece
 std::vector<piece_action> collect_all_actions(
@@ -395,6 +408,13 @@ bool is_piece_at(
   const square& coordinat
 );
 
+/// Is the square attacked by a certain (enemy) color?
+bool is_square_attacked_by(
+  const game& g,
+  const square& s,
+  const chess_color enemy_color
+);
+
 /// See if there is a piece with a certain ID at a certain square
 bool piece_with_id_is_at(
   game& g,

piece.cpp

@@ -20,6 +20,7 @@ piece::piece(
   : m_color{color},
     m_current_action_time{delta_t(0.0)},
     m_current_square{coordinat},
+    m_has_moved{false},
     m_health{::get_max_health(type)},
     m_id{create_new_id()},
     m_is_selected{false},
@@ -292,6 +293,10 @@ bool has_actions(const piece& p) noexcept
   return count_piece_actions(p) != 0;
 }
 
+bool has_moved(const piece& p) noexcept
+{
+  return p.has_moved();
+}
 
 bool is_dead(const piece& p) noexcept
 {
@@ -381,6 +386,27 @@ void test_piece()
     const auto piece{get_test_white_knight()};
     assert(piece.get_kill_count() == 0);
   }
+  // piece::has_moved
+  {
+    // a piece has not moved at the start
+    {
+      const auto piece{get_test_white_knight()};
+      assert(!piece.has_moved());
+    }
+    // a piece has moved after a movement
+    {
+      piece p(
+        chess_color::white,
+        piece_type::pawn,
+        square("e2")
+      );
+      assert(!p.has_moved());
+      p.add_action(piece_action(chess_color::white, piece_type::pawn, piece_action_type::move, square("e2"), square("e4")));
+      game g;
+      p.tick(delta_t(0.01), g);
+      assert(p.has_moved());
+    }
+  }
   // piece::get_messages
   {
     auto piece{get_test_white_knight()};
@@ -815,6 +841,7 @@ void piece::tick(
   switch(action_type)
   {
     case piece_action_type::move:
+      m_has_moved = true; // Whatever happens, this piece has tried to move
       return tick_move(*this, dt, g);
     case piece_action_type::attack:
       return tick_attack(*this, dt, g);

piece.h

@@ -69,6 +69,9 @@ class piece
   /// Get the type of piece, e.g. king, queen, rook, bishop, knight, pawn
   piece_type get_type() const noexcept { return m_type; }
 
+  /// Has this piece (attempted to) moved?
+  bool has_moved() const noexcept { return m_has_moved; }
+
   /// Increase the kill count by one
   void increase_kill_count() noexcept { ++m_kill_count; }
 
@@ -114,6 +117,9 @@ class piece
   /// The square the piece occupies now
   square m_current_square;
 
+  /// Has this piece (attempted to) move?
+  bool m_has_moved;
+
   /// The health
   double m_health;
 
@@ -200,6 +206,9 @@ piece get_test_white_knight() noexcept;
 /// Does the piece have actions to do?
 bool has_actions(const piece& p) noexcept;
 
+/// Has this piece (attempted to) move?
+bool has_moved(const piece& p) noexcept;
+
 /// Is the unit dead?
 bool is_dead(const piece& p) noexcept;
 

piece_action_type.h

@@ -8,7 +8,9 @@ enum class piece_action_type
 {
   move,
   attack,
-  promote
+  promote,
+  castle_kingside,
+  castle_queenside
 };
 
 /// Convert to string

pieces.cpp

@@ -612,6 +612,36 @@ std::vector<piece> get_pieces_queen_endgame() noexcept
   };
 }
 
+std::vector<piece> get_pieces_ready_to_castle() noexcept
+{
+  return
+  {
+    piece(chess_color::white, piece_type::rook, square("a1")),
+    piece(chess_color::white, piece_type::king, square("e1")),
+    piece(chess_color::white, piece_type::rook, square("h1")),
+    piece(chess_color::white, piece_type::pawn, square("a2")),
+    piece(chess_color::white, piece_type::pawn, square("b2")),
+    piece(chess_color::white, piece_type::pawn, square("c2")),
+    piece(chess_color::white, piece_type::pawn, square("d2")),
+    piece(chess_color::white, piece_type::pawn, square("e2")),
+    piece(chess_color::white, piece_type::pawn, square("f2")),
+    piece(chess_color::white, piece_type::pawn, square("g2")),
+    piece(chess_color::white, piece_type::pawn, square("h2")),
+    piece(chess_color::black, piece_type::rook, square("a8")),
+    piece(chess_color::black, piece_type::king, square("e8")),
+    piece(chess_color::black, piece_type::rook, square("h8")),
+    piece(chess_color::black, piece_type::pawn, square("a7")),
+    piece(chess_color::black, piece_type::pawn, square("b7")),
+    piece(chess_color::black, piece_type::pawn, square("c7")),
+    piece(chess_color::black, piece_type::pawn, square("d7")),
+    piece(chess_color::black, piece_type::pawn, square("e7")),
+    piece(chess_color::black, piece_type::pawn, square("f7")),
+    piece(chess_color::black, piece_type::pawn, square("g7")),
+    piece(chess_color::black, piece_type::pawn, square("h7"))
+  };
+}
+
+
 std::vector<piece> get_standard_starting_pieces() noexcept
 {
   return
@@ -671,6 +701,8 @@ std::vector<piece> get_starting_pieces(const starting_position_type t) noexcept
       return get_pieces_pawns_near_promotion();
     case starting_position_type::queen_end_game:
       return get_pieces_queen_endgame();
+    case starting_position_type::ready_to_castle:
+      return get_pieces_ready_to_castle();
     case starting_position_type::standard:
     default:
       assert(t == starting_position_type::standard);

pieces.h

@@ -162,6 +162,9 @@ std::vector<piece> get_pieces_pawns_near_promotion() noexcept;
 /// from a default setup
 std::vector<piece> get_pieces_queen_endgame() noexcept;
 
+/// Get the pieces for a kings that are ready to castle
+std::vector<piece> get_pieces_ready_to_castle() noexcept;
+
 /// Get all the pieces in the starting position type
 std::vector<piece> get_starting_pieces(
   const starting_position_type t

screenshots/20220808_1.png

@@ -227,15 +227,21 @@ sf::Color to_sfml_color(
     {
       return sf::Color(255 - 64, 255 - 0, 255 - 64);
     }
-    assert(t == piece_action_type::attack);
+    assert(t == piece_action_type::attack
+      || t == piece_action_type::castle_kingside
+      || t == piece_action_type::castle_queenside
+    );
     return sf::Color(255 - 0, 255 - 64, 255 - 64);
   }
   assert(color == chess_color::black);
   if (t == piece_action_type::move || t == piece_action_type::promote)
   {
     return sf::Color(128 - 64, 128 - 0, 128 - 64);
   }
-  assert(t == piece_action_type::attack);
+  assert(t == piece_action_type::attack
+    || t == piece_action_type::castle_kingside
+    || t == piece_action_type::castle_queenside
+  );
   return sf::Color(128 - 0, 128 - 64, 128 - 64);
 }