path: root/server/game.cpp

#include "game.h"

#include <boost/bind.hpp>

#include <iostream>
#include <algorithm>
#include <ctime>

bool MyDataSortPredicate(const Tile& d1, const Tile& d2)
{
  return d1.type < d2.type;
}

Game::p Game::create(Player::p player_1, Player::p player_2, Player::p player_3, Player::p player_4) {
	Game::p p(new Game(player_1, player_2, player_3, player_4));
	p->start();
	return p;
}

Game::~Game() {
	std::cout << "Game destroyed." << std::endl;
}

Game::Game(Player::p player_1, Player::p player_2, Player::p player_3, Player::p player_4) {
	players.push_back(player_1);
	players.push_back(player_2);
	players.push_back(player_3);
	players.push_back(player_4);
}

void Game::handle_ready() {
	std::cout << "Still waiting for " << waiting_players << "." << std::endl;
	
	if(--waiting_players) {
		return;
	}
	
	std::cout << "All ready!" << std::endl;
	
	round_start();
}

void Game::round_start() {
	players[0]->round_start();
	players[1]->round_start();
	players[2]->round_start();
	players[3]->round_start();

	
	// Sett opp runden sin state
	//game_state = make_shared<State>();
	
	// Simulates drawing 4, 4 ,4 for each player
	for (int i = 0; i < 3; i++) {
		for (int player_num = 0; player_num < 4; player_num++) {
			for (int y = 0; y < 4; y++) {
				game_state.players[player_num].hand.push_back(wall.take_one());
			}
		}
	}
	
	// Simulates the second part of drawing with only 1 tile
	for (int player_num = 0; player_num < 4; player_num++) {
		game_state.players[player_num].hand.push_back(wall.take_one());
	}
	
	std::sort(game_state.players[0].hand.begin(),game_state.players[0].hand.end(), MyDataSortPredicate);
	std::sort(game_state.players[1].hand.begin(),game_state.players[1].hand.end(), MyDataSortPredicate);
	std::sort(game_state.players[2].hand.begin(),game_state.players[2].hand.end(), MyDataSortPredicate);
	std::sort(game_state.players[3].hand.begin(),game_state.players[3].hand.end(), MyDataSortPredicate);

	
	
	current_player     = 3;
	num_player_actions = 0;
	draw_phase         = true;
	
	round_update();
}

void Game::round_update() {

	// We're in the draw_phase whenever a player draws a tile from the wall
	if(draw_phase) {
		// If the wall is empty (Contains only 14 tiles) when we enter draw phase the round is over.
		if(wall.is_done()) {
			round_end();
		}
		
		// Since we've entered the draw-phase it's the next players turn
		if (current_player == 3) {
			current_player = 0;
		} else {
			current_player++;	
		}
		
		#ifdef DEBUG
		
		time_t current_time = std::time(0);
		std::cout << std::ctime(&current_time) << " - Waiting for action from player: " << current_player << std::endl;
		
		#endif
	
		// Let's take a tile
		Tile from_wall = wall.take_one();
		
		// We then add the tile to the current players hand
		game_state.players[current_player].hand.push_back(from_wall);
		
		// Need to sort again.
		std::sort(game_state.players[current_player].hand.begin(),game_state.players[current_player].hand.end(), MyDataSortPredicate);
		
		// Construct the discard action that the player can do.
		Action discard;
		discard.type = Action::Discard;
		discard.player = current_player;
		
		
		game_state.possible_actions.push_back(discard);
		
		num_player_actions++;
		
		// Enter the discard phase next loop;
		draw_phase = false;
	} else {
		//Go back into draw_phase
		draw_phase = true;
		// Not implemented yet
	
	}

	// Send the updates state to the players
		
	players[0]->round_state(game_state);
	players[1]->round_state(game_state);
	players[2]->round_state(game_state);
	players[3]->round_state(game_state);
	
	// Only implemented discard so far, so only current player that needs to be able to do a action.
	if(num_player_actions > 0) {
		players[current_player]->get_action(boost::bind(&Game::handle_action, shared_from_this(), _1));
	} else {
		round_update();
	}
}

void Game::handle_action(Action action) {
	
	players[action.player]->kill_action();
	
	#ifdef DEBUG
	
	time_t current_time = std::time(0);
	std::cout << std::ctime(&current_time) << " Player: " << action.player << " Did action: " << action.type << " On target: " << action.target << std::endl;

	#endif	
	
	// Lots of actions to test if the player doing the action is allowed to do it
	
	// Check if we're actually waiting for actions.
	if (game_state.possible_actions.empty()) {
		return;
	}

	// Check if the player is allowed to do this action
	bool found_action = false;

	for(Actions::iterator it = game_state.possible_actions.begin(); it != game_state.possible_actions.end(); ++it) {
		if(it->player == action.player && it->type == action.type) {
			found_action = true;
		}
	}
	
	if(!found_action) {
		return;
	}
	
	switch ( action.type ) {
		
		case Action::Pass: {
		
		} break;
		
		case Action::Discard: {
			Tile discarded_tile = game_state.players[action.player].hand[action.target];
			game_state.players[action.player].pond.push_back(discarded_tile);
			game_state.players[action.player].hand.erase(game_state.players[action.player].hand.begin() + action.target);
			
		} break;
		
		case Action::Riichi: {
			
		} break;
		
		case Action::Chi: {
			if(most_value_action.type != Action::Pon && most_value_action.type != Action::Kan && most_value_action.type != Action::Ron) {
				most_value_action = action;
			}
		} break;
	
		case Action::Pon: {
			if(most_value_action.type != Action::Ron) {
				most_value_action = action;
			}
		} break;
		
		case Action::Kan: {
			
		} break;
		
		case Action::Ron: {
			
		} break;
		
		case Action::Tsumo: {
			
		} break;
	
		case Action::Draw: {
			
		} break;
	
		default:
			break;
	}
		
	
	num_player_actions--;
	
	// Remove all the actions that this player could do since he now did one.
	
	std::vector<int> positions;
	int position = 0;
	for(Actions::iterator it = game_state.possible_actions.begin(); it != game_state.possible_actions.end(); ++it) {
		if (it->player == action.player) {
			positions.push_back(position);
		}
		position++;
	}
	if (!positions.empty()) {
		for(std::vector<int>::iterator it = positions.begin(); it != positions.end(); ++it) {
			game_state.possible_actions.erase(game_state.possible_actions.begin() + *it);
		}
	}
	
	//When everyone has done their action we empty the list (just to be sure) and then do a round_update()
	if(num_player_actions == 0) {
		game_state.possible_actions.empty();
		round_update();
	}

	// Sjekk action, sjekk om endelig action er avgjort
	// Oppdater state
	// Evt. round_end()
}

void Game::round_end() {
	// Flere runder? round_start()
	// Ferdig? game_end()
	players[0]->round_end();
	players[1]->round_end();
	players[2]->round_end();
	players[3]->round_end();
	
	#ifdef DEBUG
	
	time_t current_time = std::time(0);
	std::cout << std::ctime(&current_time) << " Round is over..." << std::endl;
	
	#endif
}

void Game::start() {
	std::cout << "Started a game with "
		<< players[0]->nick() << ", "
		<< players[1]->nick() << ", "
		<< players[2]->nick() << " and "
		<< players[3]->nick() << "." << std::endl;
	
	players[0]->id = 0;
	players[1]->id = 1;
	players[2]->id = 2;
	players[3]->id = 3;
	
	waiting_players = 4;
	
	players[0]->game_start(boost::bind(&Game::handle_ready, shared_from_this()), players);
	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);
}