piece.h

Go to the documentation of this file.

#ifndef PIECE_H
#define PIECE_H
 
 
#include "action_history.h"
#include "delta_t.h"
#include "chess_color.h"
#include "piece_type.h"
#include "piece_action.h"
#include "piece_id.h"
#include "message_type.h"
#include "race.h"
#include "read_only.h"
 
#include <iosfwd>
#include <string>
#include <vector>
 
class piece
{
public:
  explicit piece(
    const chess_color color,
    const piece_type type,
    const square& coordinat,
    const race r = race::classic
  );
  explicit piece(
    const chess_color color,
    const piece_type type,
    const std::string& coordinat,
    const race r = race::classic
  );
 
  void add_action(const piece_action& action);
 
  void add_message(const message_type& message);
 
  void clear_messages() noexcept;
 
  const auto& get_actions() const noexcept { return m_actions; }
 
  auto& get_actions() noexcept { return m_actions; }
 
  const auto& get_action_history() const noexcept { return m_action_history; }
 
  const auto& get_color() const noexcept { return m_color.get_value(); }
 
  delta_t get_current_action_progress() const;
 
  const auto& get_current_square() const noexcept { return m_current_square; }
 
  double get_health() const noexcept { return m_health; }
 
  const piece_id& get_id() const noexcept { return m_id; }
 
  const auto& get_in_game_time() const noexcept { return m_in_game_time; }
 
  int get_kill_count() const noexcept { return m_kill_count; }
 
  double get_max_health() const noexcept { return m_max_health; }
 
  double get_max_shield() const;
 
  const auto& get_messages() const noexcept { return m_messages; }
 
  const auto& get_race() const noexcept { return m_race.get_value(); }
 
  double get_shield() const;
 
  const auto& get_type() const noexcept { return m_type.get_value(); }
 
  bool has_moved() const noexcept { return m_has_moved; }
 
  void increase_kill_count() noexcept { ++m_kill_count; }
 
  bool is_enpassantable(const in_game_time& when) const;
 
 
  void receive_damage(const double damage);
 
  void set_current_action_progress(const delta_t& t) noexcept;
 
  void set_current_square(const square& s) noexcept { m_current_square = s; }
 
 
  void tick(
    const delta_t& dt,
    game& g
  );
 
private:
 
  std::vector<piece_action> m_actions;
 
  action_history m_action_history;
 
  read_only<chess_color> m_color;
 
  delta_t m_current_action_progress;
 
  square m_current_square;
 
  bool m_has_moved;
 
  double m_health;
 
  piece_id m_id;
 
  in_game_time m_in_game_time;
 
  int m_kill_count;
 
  double m_max_health;
 
  double m_max_shield;
 
  std::vector<message_type> m_messages;
 
  read_only<race> m_race;
 
  double m_shield;
 
  read_only<piece_type> m_type;
};
 
bool can_attack_on_empty_board(
  const chess_color color,
  const piece_type& p,
  const square& from,
  const square& to
);
 
bool can_capture(
  const piece_type& p,
  const square& from,
  const square& to,
  const chess_color color
);
 
bool can_move_on_empty_board(
  const chess_color color,
  const piece_type& p,
  const square& from,
  const square& to
);
 
bool can_promote(
  const chess_color color,
  const piece_type& p,
  const square& s
) noexcept;
 
bool can_promote(const piece& p) noexcept;
 
void clear_actions(piece& p);
 
int count_piece_actions(const piece& p);
 
std::string describe_actions(const piece& p);
 
double get_f_health(const piece& p) noexcept;
 
double get_f_shield(const piece& p) noexcept;
 
square get_occupied_square(const piece& p) noexcept;
 
piece get_test_white_king() noexcept;
 
piece get_test_white_knight(const race r = race::classic) noexcept;
 
bool has_actions(const piece& p) noexcept;
 
bool has_just_double_moved(
  const piece& p,
  const in_game_time& when
) noexcept;
 
bool has_moved(const piece& p) noexcept;
 
 
bool is_dead(const piece& p) noexcept;
 
bool is_enpassantable(
  const piece& p,
  const in_game_time& when
);
 
bool is_idle(const piece& p) noexcept;
 
bool is_on_starting_rank(const chess_color c, const square& q) noexcept;
 
bool is_pawn(const piece& p) noexcept;
 
bool is_selected(const piece& p);
 
void test_piece();
 
void tick_attack(
  piece& p,
  const delta_t& dt,
  game& g
);
 
void tick_attack_en_passant(
  piece& p,
  const delta_t& dt,
  game& g
);
 
void tick_castle_kingside(
  piece& p,
  const delta_t& dt,
  game& g
);
 
void tick_castle_queenside(
  piece& p,
  const delta_t& dt,
  game& g
);
 
void tick_move(
  piece& p,
  const delta_t& dt,
  game& g
);
 
char to_fen_char(const piece& p) noexcept;
 
bool operator==(const piece& lhs, const piece& rhs) noexcept;
bool operator!=(const piece& lhs, const piece& rhs) noexcept;
 
std::ostream& operator<<(std::ostream& os, const piece& p) noexcept;
 
#endif // PIECE_H