1 files changed, 155 insertions, 0 deletions
diff --git a/server/game.cpp b/server/game.cpp
index 07373ac..f2b1c06 100644
--- a/server/game.cpp
+++ b/server/game.cpp
@@ -142,4 +142,159 @@ void Game::start() {
 	players[1]->game_start(boost::bind(&Game::handle_ready, shared_from_this()), players);
 	players[2]->game_start(boost::bind(&Game::handle_ready, shared_from_this()), players);
 	players[3]->game_start(boost::bind(&Game::handle_ready, shared_from_this()), players);
+void Game::Player::round_start() {
+	// Reset contents.
+	hand.clear();
+	open.clear();
+	pond.clear();
+	riichi = false;
+	
+	// Notify client of round start.
+	client->round_start();
+}
+
+State::Player Game::Player::get_state() {
+	State::Player state = {hand, open, pond};
+	return state;
+}
+
+State::Player Game::Player::get_state_filtered() {
+	State::Player state = {hand, open, pond};
+	return state;
+}
+
+Actions Game::Player::get_actions_draw() {
+	Actions possible_actions;
+	
+	// Check if player can force a draw.
+	// Check if player can tsumo.
+	// Check if player can declare a concealed kan or extend an open pon. List all possibilities.
+	
+	if(!riichi) {
+		// Check if player can riichi.
+		
+		// List all tiles that can be discarded.
+		for(std::size_t i = 0; i < hand.size(); i++) {
+			possible_actions.push_back(Action(Action::Discard, i));
+		}
+	
+	} else {
+		// Only tile that can be discarded is the last drawn one.
+		possible_actions.push_back(Action(Action::Discard, hand.size() - 1));
+	}
+	
+	return possible_actions;
+}
+
+Actions Game::Player::get_actions_discard(Tile tile) {
+	Actions possible_actions;
+	
+	if(!riichi) {
+		// Check if tile can be called for a chi. Enumerate all combinations.
+		Targets targets = can_chi(tile);
+		if(!targets.empty()) {
+			for(Targets::iterator it = targets.begin(); it != targets.end(); it++) {
+				possible_actions.push_back(Action(Action::Chi, *it));
+			}
+		}
+		
+		// Check if tile can be called for a pon.
+		int target = can_pon(tile);
+		if(target > 0) {
+			possible_actions.push_back(Action(Action::Pon, target));
+			
+			// Check if tile can be called for a kan.
+			if(can_kan(tile, target)) {
+				possible_actions.push_back(Action(Action::Kan, target));
+			}
+		}
+	}
+	
+	// Check if tile can be ron-ed.
+	
+	// If any action is possible, add option to pass.
+	if(possible_actions) {
+		possible_actions.push_back(Action::Pass);
+	}
+	
+	return possible_actions;
+}
+
+Game::Player::Targets Game::Player::can_chi(Tile tile) {
+	Targets targets;
+	
+	Tile::Set set = tile.get_set();
+	int num = tile.get_num();
+	
+	// Check if tile actually can be chi-ed.
+	if(set == Tile::Honor) {
+		return targets;
+	}
+	
+	bool have_above = false;
+	
+	// Check if we have tile below.
+	Tiles::iterator it = std::find(hand.begin(), hand.end(), Tile(set, num - 1));
+	if(num > 1 && it != hand.end()) {
+		
+		// Check if we also have tile below tile below.
+		Tiles::iterator it2 = std::find(hand.begin(), hand.end(), Tile(set, num - 2));
+		if(num > 2 && it2 != hand.end()) {
+			targets.push_back(it2 - hand.begin()); // (T-2 T-1 T)
+		}
+		
+		// Check if we have tile above.
+		it2 = std::find(hand.begin(), hand.end(), Tile(set, num + 1));
+		if(num < 9 && it2 != hand.end()) {
+			targets.push_back(it - hand.begin()); // (T-1 T T+1)
+			have_above = true;
+			it = it2;
+		}
+	}
+	
+	// Check if we have tile above.
+	if(have_above || (it = std::find(hand.begin(), hand.end(), Tile(set, num + 1))) != hand.end()) {
+		// Check if we have tile above tile above.
+		Tiles::iterator it2 = std::find(hand.begin(), hand.end(), Tile(set, num + 2));
+		if(num < 8 && it2 != hand.end()) {
+			targets.push_back(it - hand.begin()); // (T T+1 T+2)
+		}
+	}
+	
+	return targets;
+}
+
+int Game::Player::can_pon(Tile tile) {
+	Tiles::iterator it = std::find(hand.begin(), hand.end(), tile);
+	if(it + 1 < hand.end() && it[1] == tile) {
+		return it - hand.begin();
+	}
+	
+	return -1;
+}
+
+//Game::Player::Targets Game::Player::can_kan() {
+//	return Targets(); // TODO
+//}
+
+bool Game::Player::can_kan(Tile tile, int target) {
+	if(std::size_t(target + 2) < hand.size() && hand[target + 2] == tile) {
+		return true;
+	}
+	return false;
+}
+
+void Game::Player::draw(Tile tile) {
+	hand.push_back(tile);
+}
+
+void Game::Player::discard(int target) {
+	Tile tile = hand[target];
+	hand.erase(hand.begin() + target);
+	hand.sort();
+	pond.push_back(tile);
+}
+
+Tile Game::Player::last_discard() {
+	return pond.back();
 }