void replay_controller::replay_next_side(){
is_playing_ = true;
replay_ui_playback_should_start();
play_side(player_number_ - 1, false);
while (current_team().is_empty()) {
play_side(player_number_ - 1, false);
}
if (!skip_replay_ || !is_playing_) {
gui_->scroll_to_leader(units_, player_number_,game_display::ONSCREEN,false);
}
replay_ui_playback_should_stop();
}
possible_end_play_signal replay_controller::replay_next_side(){
is_playing_ = true;
replay_ui_playback_should_start();
HANDLE_END_PLAY_SIGNAL( play_side() );
while (current_team().is_empty()) {
HANDLE_END_PLAY_SIGNAL( play_side() );
}
if (!skip_replay_ || !is_playing_) {
gui_->scroll_to_leader(player_number_,game_display::ONSCREEN,false);
}
replay_ui_playback_should_stop();
return boost::none;
}
void playsingle_controller::play_turn()
{
whiteboard_manager_->on_gamestate_change();
gui_->new_turn();
gui_->invalidate_game_status();
events::raise_draw_event();
LOG_NG << "turn: " << turn() << "\n";
if(non_interactive()) {
LOG_AIT << "Turn " << turn() << ":" << std::endl;
}
for (; player_number_ <= int(gamestate_.board_.teams().size()); ++player_number_)
{
// If a side is empty skip over it.
if (current_team().is_empty()) continue;
{
save_blocker blocker;
init_side_begin(false);
if(init_side_done_) {
//This is the case in a reloaded game where teh side was initilizes before saving the game.
init_side_end();
}
}
ai_testing::log_turn_start(player_number_);
play_side();
if(is_regular_game_end()) {
return;
}
finish_side_turn();
if(is_regular_game_end()) {
return;
}
if(non_interactive()) {
LOG_AIT << " Player " << player_number_ << ": " <<
current_team().villages().size() << " Villages" <<
std::endl;
ai_testing::log_turn_end(player_number_);
}
}
//If the loop exits due to the last team having been processed,
//player_number_ will be 1 too high
//TODO: Why else could the loop exit?
if(player_number_ > static_cast<int>(gamestate_.board_.teams().size()))
player_number_ = gamestate_.board_.teams().size();
finish_turn();
// Time has run out
check_time_over();
}
void play_controller::play_turn()
{
whiteboard_manager_->on_gamestate_change();
gui_->new_turn();
gui_->invalidate_game_status();
events::raise_draw_event();
LOG_NG << "turn: " << turn() << "\n";
if(gui_->video().non_interactive()) {
LOG_AIT << "Turn " << turn() << ":" << std::endl;
}
for (; gamestate_->player_number_ <= int(gamestate().board_.teams().size()); ++gamestate_->player_number_)
{
// If a side is empty skip over it.
if (current_team().is_empty()) {
continue;
}
init_side_begin();
if(gamestate_->init_side_done()) {
// This is the case in a reloaded game where the side was initialized before saving the game.
init_side_end();
}
ai_testing::log_turn_start(current_side());
play_side();
if(is_regular_game_end()) {
return;
}
finish_side_turn();
if(is_regular_game_end()) {
return;
}
if(gui_->video().non_interactive()) {
LOG_AIT << " Player " << current_side() << ": " <<
current_team().villages().size() << " Villages" <<
std::endl;
ai_testing::log_turn_end(current_side());
}
}
// If the loop exits due to the last team having been processed.
gamestate_->player_number_ = gamestate().board_.teams().size();
finish_turn();
// Time has run out
check_time_over();
}
void replay_controller::play_turn(){
LOG_REPLAY << "turn: " << current_turn_ << "\n";
gui_->new_turn();
gui_->invalidate_game_status();
events::raise_draw_event();
bool last_team = false;
while ( (!last_team) && (!recorder.at_end()) && is_playing_ ){
last_team = static_cast<size_t>(player_number_) == teams_.size();
play_side(player_number_ - 1, false);
play_slice();
}
}
// @save: It isn't mean this is loaded game. it mean whether execute auto-save.
// false: this is first turn of loaded game, true: this isn't first turn or this isn't loaded game.
void playsingle_controller::play_turn(bool save)
{
gui_->new_turn();
gui_->invalidate_game_status();
events::raise_draw_event();
play_side();
check_victory();
// Time has run out
check_time_over();
finish_turn();
}
void replay_controller::replay_next_side(){
is_playing_ = true;
buttons_.playback_should_start();
play_side(player_number_ - 1, false);
if (static_cast<size_t>(player_number_) > teams_.size()) {
player_number_ = 1;
current_turn_++;
}
if (!skip_replay_ || !is_playing_) {
gui_->scroll_to_leader(units_, player_number_,game_display::ONSCREEN,false);
}
buttons_.playback_should_stop(is_playing_);
}
//make all sides move, then stop
possible_end_play_signal replay_controller::play_turn(){
LOG_REPLAY << "turn: " << current_turn_ << "\n";
gui_->new_turn();
gui_->invalidate_game_status();
events::raise_draw_event();
bool last_team = false;
while ( (!last_team) && (!recorder.at_end()) && is_playing_ ){
last_team = static_cast<size_t>(player_number_) == gamestate_.board_.teams().size();
PROPOGATE_END_PLAY_SIGNAL( play_side() );
HANDLE_END_PLAY_SIGNAL( play_slice() );
}
return boost::none;
}
void replay_controller::replay_next_side(){
is_playing_ = true;
play_side(player_number_ - 1, false);
if (static_cast<size_t>(player_number_) > teams_.size()) {
player_number_ = 1;
current_turn_++;
}
if (!skip_replay_) {
gui_->scroll_to_leader(units_, player_number_,game_display::ONSCREEN,false);
}
is_playing_ = false;
gui::button* b = gui_->find_button("button-nextside");
if (b != NULL) { b->release(); }
}
// @save: It isn't mean this is loaded game. it mean whether execute auto-save.
// false: this is first turn of loaded game, true: this isn't first turn or this isn't loaded game.
void playsingle_controller::play_turn(bool save)
{
gui_->new_turn();
gui_->invalidate_game_status();
events::raise_draw_event();
for (player_number_ = first_player_; player_number_ <= int(teams_.size()); ++player_number_) {
unit_display::player_number_ = player_number_;
// If a side is empty skip over it.
if (current_team().is_empty()) continue;
try {
save_blocker blocker;
init_side(player_number_ - 1, false, save || (player_number_ != first_player_));
} catch (end_turn_exception) {
if (current_team().is_network() == false) {
turn_info turn_data(player_number_, replay_sender_, undo_stack_);
recorder.end_turn();
turn_data.sync_network();
}
continue;
}
// If a side is dead end the turn.
if (current_team().is_human() && side_units(player_number_) == 0) {
turn_info turn_data(player_number_, replay_sender_, undo_stack_);
recorder.end_turn();
turn_data.sync_network();
continue;
}
play_side(player_number_, save);
finish_side_turn();
check_victory();
//if loading a savegame, network turns might not have reset this yet
loading_game_ = false;
}
// Time has run out
check_time_over();
finish_turn();
}
void playsingle_controller::play_turn(bool save)
{
resources::whiteboard->on_gamestate_change();
gui_->new_turn();
gui_->invalidate_game_status();
events::raise_draw_event();
LOG_NG << "turn: " << turn() << "\n";
if(non_interactive())
std::cout << "Turn " << turn() << ":" << std::endl;
for (player_number_ = first_player_; player_number_ <= int(teams_.size()); ++player_number_)
{
// If a side is empty skip over it.
if (current_team().is_empty()) continue;
try {
save_blocker blocker;
init_side(player_number_ - 1);
} catch (end_turn_exception) {
if (current_team().is_network() == false) {
turn_info turn_data(player_number_, replay_sender_);
recorder.end_turn();
turn_data.sync_network();
}
continue;
}
if (replaying_) {
LOG_NG << "doing replay " << player_number_ << "\n";
replaying_ = ::do_replay(player_number_);
LOG_NG << "result of replay: " << (replaying_?"true":"false") << "\n";
} else {
// If a side is dead end the turn, but play at least side=1's
// turn in case all sides are dead
if (current_team().is_human() && side_units(player_number_) == 0
&& (resources::units->size() != 0 || player_number_ != 1))
{
turn_info turn_data(player_number_, replay_sender_);
recorder.end_turn();
turn_data.sync_network();
continue;
}
ai_testing::log_turn_start(player_number_);
play_side(player_number_, save);
}
finish_side_turn();
if(non_interactive()) {
std::cout << " Player " << player_number_ << ": " <<
current_team().villages().size() << " Villages" <<
std::endl;
ai_testing::log_turn_end(player_number_);
}
check_victory();
//if loading a savegame, network turns might not have reset this yet
loading_game_ = false;
}
finish_turn();
// Time has run out
check_time_over();
}
possible_end_play_signal playsingle_controller::play_turn()
{
whiteboard_manager_->on_gamestate_change();
gui_->new_turn();
gui_->invalidate_game_status();
events::raise_draw_event();
LOG_NG << "turn: " << turn() << "\n";
if(non_interactive()) {
LOG_AIT << "Turn " << turn() << ":" << std::endl;
}
for (player_number_ = first_player_; player_number_ <= int(gamestate_.board_.teams().size()); ++player_number_)
{
// If a side is empty skip over it.
if (current_team().is_empty()) continue;
possible_end_play_signal signal;
{
save_blocker blocker;
signal = init_side();
}
if (signal) {
switch (boost::apply_visitor(get_signal_type(), *signal)) {
case END_TURN:
if (current_team().is_network() == false) {
turn_data_.send_data();
recorder.end_turn();
turn_data_.sync_network();
}
continue;
case END_LEVEL:
return signal;
}
}
if (replaying_) {
LOG_NG << "doing replay " << player_number_ << "\n";
HANDLE_END_PLAY_SIGNAL ( replaying_ = ::do_replay() == REPLAY_FOUND_END_TURN );
LOG_NG << "result of replay: " << (replaying_?"true":"false") << "\n";
} else {
ai_testing::log_turn_start(player_number_);
PROPOGATE_END_PLAY_SIGNAL ( play_side() );
}
finish_side_turn();
if(non_interactive()) {
LOG_AIT << " Player " << player_number_ << ": " <<
current_team().villages().size() << " Villages" <<
std::endl;
ai_testing::log_turn_end(player_number_);
}
HANDLE_END_PLAY_SIGNAL ( check_victory() );
//if loading a savegame, network turns might not have reset this yet
loading_game_ = false;
}
//If the loop exits due to the last team having been processed,
//player_number_ will be 1 too high
if(player_number_ > static_cast<int>(gamestate_.board_.teams().size()))
player_number_ = gamestate_.board_.teams().size();
finish_turn();
// Time has run out
PROPOGATE_END_PLAY_SIGNAL ( check_time_over() );
return boost::none;
}