diff options
Diffstat (limited to 'src/player.h')
-rw-r--r-- | src/player.h | 118 |
1 files changed, 118 insertions, 0 deletions
diff --git a/src/player.h b/src/player.h new file mode 100644 index 0000000..a4b3416 --- /dev/null +++ b/src/player.h @@ -0,0 +1,118 @@ +#ifndef PLAYER_H +#define PLAYER_H + +#include "client.h" +#include "score.h" + +#include "../common/set.h" +#include "../common/cyclicint.h" +#include "../common/state.h" +#include "../common/action.h" + +typedef CyclicInt<4> PlayerNum; + +class Player { + public: + ClientBase::p client; + + Tiles hand; + Sets open; + Tiles pond; + bool riichi; + int score; + int wind; + + //! Indexes of tiles that will give tenpai (used after riichi declaration). + List<int> tenpai_indexes; + + //! Player has won. + bool won; + + //! List of han in winning hand. + List<std::pair<std::string, int> > won_han; + + //! Value of winning hand. + Score won_value; + + //! Prepare for a new round. + void round_start(int w); + + //! Get a state snapshot. + PlayerState get_state(); + + //! Get a state snapshot, with concealed tiles filtered. + PlayerState get_state_filtered(); + + //! Get possible actions after a draw. + Actions get_actions_draw(); + + //! Get possible actions on discarded tile. + Actions get_actions_discard(Tile tile, PlayerNum discarder); + + typedef std::vector<int> Targets; + + //! Check if player can declare riichi. + bool can_riichi(); + + //! Check if tile can be called for a chi. + Targets can_chi(Tile tile); + + //! Check if tile can be called for a pon. + int can_pon(Tile tile); + + //! Check if it's possible to make a concealed kan. + Targets can_kan(); + + //! Check if it's possible to extend a pon to a kan. + Targets can_kan_extend(); + + //! Check if tile can be called to kan target. + bool can_kan(Tile tile, int target); + + //! Check if hand is complete. + bool can_tsumo(); + + //! Check if tile can be called to complete hand. + bool can_ron(Tile tile); + + //! Draw tile. + void draw(Tile tile); + + //! Discard tile. + void discard(int target); + + //! Look at last discard in pond. + Tile last_discard(); + + //! Claim last discard from pond. + Tile claim(); + + //! Declare riichi. + void declare_riichi(); + + //! Make chi from tile. + void make_chi(Tile tile, int target); + + //! Make pon from tile. + void make_pon(Tile tile, int target, PlayerNum discarder); + + //! Make open kan from tile. + void make_kan(Tile tile, int target, PlayerNum discarder); + + //! Make concealed kan. + void make_kan(int target); + + //! Make extended kan. + void make_kan_extend(int target); + + //! Declare win on discarded tile. + void declare_ron(Tile tile); + + //! Declare win on self-drawn tile. + void declare_tsumo(); + + //! Calculate score for winning hand combination. + Score calculate_score(const Sets& hand, List<std::pair<std::string, int> >& han, bool tsumo); +}; + +#endif |