Can detect if a pawn just moved two squares

Author: richelbilderbeek

action_history.cpp

@@ -26,6 +26,22 @@ void action_history::add_action(const delta_t& t, const piece_action& action) no
   m_timed_actions.push_back(std::make_pair(t, action));
 }
 
+std::vector<piece_action> collect_actions_in_timespan(
+  const action_history& history,
+  const delta_t from,
+  const delta_t to
+)
+{
+  assert(from < to);
+  std::vector<piece_action> actions;
+  for (const auto& p: history.get_timed_actions())
+  {
+    const delta_t& t{p.first};
+    if (t >= from && t <= to) actions.push_back(p.second);
+  }
+  return actions;
+}
+
 const piece_action& get_last_action(const action_history& history)
 {
   assert(has_actions(history));
@@ -37,6 +53,28 @@ bool has_actions(const action_history& history) noexcept
   return !history.get_timed_actions().empty();
 }
 
+bool has_just_double_moved(
+  const action_history& history,
+  const delta_t when
+)
+{
+  // It takes 1 time unit to do a move
+  const delta_t start_earliest{when - delta_t(2.0)};
+  const delta_t start_latest{when - delta_t(1.0)};
+  const std::vector<piece_action> actions{
+    collect_actions_in_timespan(
+      history,
+      start_earliest,
+      start_latest
+    )
+  };
+  for (const piece_action a: actions)
+  {
+    if (is_double_move(a)) return true;
+  }
+  return false;
+}
+
 action_history merge_action_histories(const std::vector<action_history> histories)
 {
   std::vector<std::pair<delta_t, piece_action>> timed_actions;

action_history.h

@@ -14,17 +14,36 @@ class action_history
     const std::vector<std::pair<delta_t, piece_action>>& timed_actions  = {}
   );
 
+  /// Add an action, when started
   void add_action(const delta_t& t, const piece_action& action) noexcept;
 
   const auto& get_timed_actions() const noexcept { return m_timed_actions; }
 
 private:
 
-  /// The history of actions, in chrononical order
+  /// The history of actions (i.e when they started), in chrononical order
   std::vector<std::pair<delta_t, piece_action>> m_timed_actions;
 
 };
 
+/// Collect all the actions that started in the timespan
+std::vector<piece_action> collect_actions_in_timespan(
+  const action_history& history,
+  const delta_t from,
+  const delta_t to
+);
+
+/// Has this piece (i.e. a pawn) just finish a double move forward last time unit?
+/// Only pawns can do this, e.g. e2-e4 or e7-e5
+/// For example, when at t=0.5, e2-e4 is played,
+/// from t=1.5 to t=2.5 this function will return true.
+/// Before that, the piece was moving
+/// After that, it was too long ago for en-passant
+bool has_just_double_moved(
+  const action_history& action_history,
+  const delta_t when
+);
+
 const piece_action& get_last_action(const action_history& history);
 
 bool has_actions(const action_history& history) noexcept;

delta_t.cpp

@@ -100,6 +100,11 @@ bool operator<(const delta_t& lhs, const delta_t& rhs) noexcept
   return lhs.get() < rhs.get();
 }
 
+bool operator<=(const delta_t& lhs, const delta_t& rhs) noexcept
+{
+  return lhs.get() <= rhs.get();
+}
+
 delta_t& operator+=(delta_t& lhs, const delta_t& rhs) noexcept
 {
   lhs = lhs + rhs;

delta_t.h

@@ -25,6 +25,7 @@ void test_delta_t();
 
 bool operator==(const delta_t& lhs, const delta_t& rhs) noexcept;
 bool operator<(const delta_t& lhs, const delta_t& rhs) noexcept;
+bool operator<=(const delta_t& lhs, const delta_t& rhs) noexcept;
 delta_t& operator+=(delta_t& lhs, const delta_t& rhs) noexcept;
 delta_t operator+(const delta_t& lhs, const delta_t& rhs) noexcept;
 delta_t operator-(const delta_t& lhs, const delta_t& rhs) noexcept;

game.cpp

@@ -387,7 +387,14 @@ std::vector<piece_action> collect_all_pawn_actions(
   assert(type == piece_type::pawn);
   const auto move_actions{collect_all_pawn_move_actions(g, p)};
   const auto attack_actions{collect_all_pawn_attack_actions(g, p)};
-  return concatenate(move_actions, attack_actions);
+  const auto en_passant_actions{collect_all_pawn_en_passant_actions(g, p)};
+  return concatenate(
+    concatenate(
+      move_actions,
+      attack_actions
+    ),
+    en_passant_actions
+  );
 }
 
 std::vector<piece_action> collect_all_pawn_attack_actions(
@@ -456,6 +463,81 @@ std::vector<piece_action> collect_all_pawn_attack_actions(
   return actions;
 }
 
+std::vector<piece_action> collect_all_pawn_en_passant_actions(
+  const game& g,
+  const piece& p
+)
+{
+  std::vector<piece_action> actions;
+  const auto type{p.get_type()};
+  assert(type == piece_type::pawn);
+  const auto& s{p.get_current_square()};
+  const auto x{s.get_x()};
+  const auto y{s.get_y()};
+  const auto color{p.get_color()};
+  const auto& from{p.get_current_square()};
+  const auto enemy_color{get_other_color(color)};
+  if (color == chess_color::black)
+  {
+    if (x != 3) return {};
+    {
+      if (y > 0)
+      {
+        const square to_square{square(x - 1, y - 1)};
+        const square enemy_square{square(x, y - 1)};
+        if (is_empty(g, to_square)
+          && is_piece_at(g, enemy_square)
+          && get_piece_at(g, enemy_square).get_color() == enemy_color
+          && has_just_double_moved(get_piece_at(g, enemy_square), g.get_time())
+        )
+        {
+          actions.push_back(piece_action(color, type, piece_action_type::en_passant, from, to_square));
+        }
+      }
+      if (y < 7)
+      {
+        const square to_square{square(x - 1, y + 1)};
+        const square enemy_square{square(x, y + 1)};
+        if (is_empty(g, to_square)
+          && is_piece_at(g, enemy_square)
+          && get_piece_at(g, enemy_square).get_color() == enemy_color
+          && has_just_double_moved(get_piece_at(g, enemy_square), g.get_time())
+        )
+        {
+          actions.push_back(piece_action(color, type, piece_action_type::en_passant, from, to_square));
+        }
+      }
+    }
+  }
+  else
+  {
+    assert(color == chess_color::white);
+    assert(get_rank(s) != 1);
+    // Attack
+    if (x != 7)
+    {
+      if (y > 0)
+      {
+        const square enemy_square{square(x + 1, y - 1)};
+        if (is_piece_at(g, enemy_square) && get_piece_at(g, enemy_square).get_color() == enemy_color)
+        {
+          actions.push_back(piece_action(color, type, piece_action_type::attack, from, enemy_square));
+        }
+      }
+      if (y < 7)
+      {
+        const square enemy_square{square(x + 1, y + 1)};
+        if (is_piece_at(g, enemy_square) && get_piece_at(g, enemy_square).get_color() == enemy_color)
+        {
+          actions.push_back(piece_action(color, type, piece_action_type::attack, from, enemy_square));
+        }
+      }
+    }
+  }
+  return actions;
+}
+
+
 std::vector<piece_action> collect_all_pawn_move_actions(
   const game& g,
   const piece& p

game.h

@@ -165,6 +165,13 @@ std::vector<piece_action> collect_all_pawn_attack_actions(
   const piece& p
 );
 
+/// Collect all valid attack actions at a board
+/// for a focal pawn
+std::vector<piece_action> collect_all_pawn_en_passant_actions(
+  const game& g,
+  const piece& p
+);
+
 /// Collect all valid move actions at a board
 /// for a focal pawn
 std::vector<piece_action> collect_all_pawn_move_actions(

piece.cpp

@@ -305,6 +305,14 @@ bool has_actions(const piece& p) noexcept
   return count_piece_actions(p) != 0;
 }
 
+bool has_just_double_moved(
+  const piece& p,
+  const delta_t when
+) noexcept
+{
+  return has_just_double_moved(p.get_action_history(), when);
+}
+
 bool has_moved(const piece& p) noexcept
 {
   return p.has_moved();
@@ -661,6 +669,25 @@ void test_piece()
     const auto p{get_test_white_king()};
     assert(!has_actions(p));
   }
+  // has_just_double_moved
+  {
+    action_history h;
+    assert(!has_just_double_moved(h, delta_t(2.0)));
+    h.add_action(
+      delta_t(0.5),
+      piece_action(
+        chess_color::white,
+        piece_type::pawn,
+        piece_action_type::move,
+        "e2",
+        "e4"
+      )
+    );
+    assert(!has_just_double_moved(h, delta_t(0.0)));
+    assert(!has_just_double_moved(h, delta_t(1.0)));
+    assert(has_just_double_moved(h, delta_t(2.0)));
+    assert(!has_just_double_moved(h, delta_t(3.0)));
+  }
   // is_idle
   {
     const auto p{get_test_white_king()};

piece.h

@@ -218,9 +218,17 @@ piece get_test_white_knight() noexcept;
 /// Does the piece have actions to do?
 bool has_actions(const piece& p) noexcept;
 
+/// Has this piece (i.e. a pawn) did a double move forward last time unit?
+/// Only pawns can do this, e.g. e2-e4 or e7-e5
+bool has_just_double_moved(
+  const piece& p,
+  const delta_t when
+) 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.cpp

@@ -49,6 +49,13 @@ piece_action get_test_piece_action() noexcept
   );
 }
 
+bool is_double_move(const piece_action& a) noexcept
+{
+  return a.get_piece_type() == piece_type::pawn
+    && a.get_action_type() == piece_action_type::move
+    && std::abs(a.get_from().get_x() - a.get_to().get_x()) == 2;
+}
+
 bool is_atomic(const piece_action& a) noexcept
 {
   if (a.get_from() == a.get_to()) return true;

piece_action.h

@@ -56,10 +56,13 @@ std::string describe_action(const piece_action& p);
 /// Get a piece_action to be used in testing
 piece_action get_test_piece_action() noexcept;
 
+/// Is this a pawn moving two squares forward?
+bool is_double_move(const piece_action& a) noexcept;
+
 /// Is the action atomic, i.e. it cannot be split up further.
 /// For example, moving a queen d1 to d3 is not atomic,
 /// as it is split up in d1 -> d2 -> d3
-bool is2_atomic(const piece_action& a) noexcept;
+bool is_atomic(const piece_action& a) noexcept;
 
 /// Test the 'piece_action' class and its free functions
 void test_piece_action();