//make only one side move void replay_controller::play_side(const unsigned int /*team_index*/, bool){ DBG_REPLAY << "Status turn number: " << turn() << "\n"; DBG_REPLAY << "Replay_Controller turn number: " << current_turn_ << "\n"; DBG_REPLAY << "Player number: " << player_number_ << "\n"; try{ // If a side is empty skip over it. bool has_end_turn = true; if (!current_team().is_empty()) { statistics::reset_turn_stats(current_team().save_id()); play_controller::init_side(player_number_ - 1, true); DBG_REPLAY << "doing replay " << player_number_ << "\n"; // if have reached the end we don't want to execute finish_side_turn and finish_turn // becasue we might not have enough data to execute them (like advancements during turn_end for example) // !has_end_turn == we reached the end of teh replay without finding and end turn tag. has_end_turn = do_replay(player_number_); if(!has_end_turn) { return; } finish_side_turn(); } player_number_++; if (static_cast<size_t>(player_number_) > teams_.size()) { //during the orginal game player_number_ would also be teams_.size(), player_number_ = teams_.size(); finish_turn(); tod_manager_.next_turn(); it_is_a_new_turn_ = true; player_number_ = 1; current_turn_++; gui_->new_turn(); } // This is necessary for replays in order to show possible movements. BOOST_FOREACH(unit &u, units_) { if (u.side() == player_number_) { u.new_turn(); } } update_teams(); update_gui(); } catch(end_level_exception& e){ //VICTORY/DEFEAT end_level_exception shall not return to title screen if (e.result != VICTORY && e.result != DEFEAT) throw; } }
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_side(const unsigned int /*team_index*/, bool){ if (recorder.at_end()){ return; } DBG_REPLAY << "Status turn number: " << turn() << "\n"; DBG_REPLAY << "Replay_Controller turn number: " << current_turn_ << "\n"; DBG_REPLAY << "Player number: " << player_number_ << "\n"; try{ // If a side is empty skip over it. if (!current_team().is_empty()) { statistics::reset_turn_stats(current_team().save_id()); play_controller::init_side(player_number_ - 1, true); DBG_REPLAY << "doing replay " << player_number_ << "\n"; do_replay(player_number_); finish_side_turn(); // This is necessary for replays in order to show possible movements. for (unit_map::iterator uit = units_.begin(); uit != units_.end(); ++uit) { if (uit->second.side() != player_number_) { uit->second.new_turn(); } } } player_number_++; if (static_cast<size_t>(player_number_) > teams_.size()) { next_turn(); finish_turn(); player_number_ = 1; current_turn_++; } update_teams(); update_gui(); } catch(end_level_exception& e){ //VICTORY/DEFEAT end_level_exception shall not return to title screen if ((e.result != VICTORY) && (e.result != DEFEAT)) { throw e; } } }
// @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(); }
//make only one side move void replay_controller::play_side(const unsigned int /*team_index*/, bool){ DBG_REPLAY << "Status turn number: " << turn() << "\n"; DBG_REPLAY << "Replay_Controller turn number: " << current_turn_ << "\n"; DBG_REPLAY << "Player number: " << player_number_ << "\n"; try{ // If a side is empty skip over it. if (!current_team().is_empty()) { statistics::reset_turn_stats(current_team().save_id()); play_controller::init_side(player_number_ - 1, true); DBG_REPLAY << "doing replay " << player_number_ << "\n"; do_replay(player_number_); finish_side_turn(); // This is necessary for replays in order to show possible movements. foreach (unit &u, units_) { if (u.side() != player_number_) { u.new_turn(); } } } player_number_++; if (static_cast<size_t>(player_number_) > teams_.size()) { finish_turn(); tod_manager_.next_turn(); it_is_a_new_turn_ = true; player_number_ = 1; current_turn_++; gui_->new_turn(); } update_teams(); update_gui(); }
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; }
//make only one side move possible_end_play_signal replay_controller::play_side() { DBG_REPLAY << "Status turn number: " << turn() << "\n"; DBG_REPLAY << "Replay_Controller turn number: " << current_turn_ << "\n"; DBG_REPLAY << "Player number: " << player_number_ << "\n"; // If a side is empty skip over it. if (!current_team().is_empty()) { statistics::reset_turn_stats(current_team().save_id()); possible_end_play_signal signal = play_controller::init_side(true); if (signal) { switch (boost::apply_visitor(get_signal_type(), *signal) ) { case END_TURN: return signal; case END_LEVEL: //VICTORY/DEFEAT end_level_exception shall not return to title screen LEVEL_RESULT res = boost::apply_visitor(get_result(), *signal); if ( res != VICTORY && res != DEFEAT ) return signal; } } DBG_REPLAY << "doing replay " << player_number_ << "\n"; // if have reached the end we don't want to execute finish_side_turn and finish_turn // becasue we might not have enough data to execute them (like advancements during turn_end for example) try { if(do_replay() != REPLAY_FOUND_END_TURN) { // We reached the end of teh replay without finding and end turn tag. return boost::none; } } catch(end_level_exception& e){ //VICTORY/DEFEAT end_level_exception shall not return to title screen if (e.result != VICTORY && e.result != DEFEAT) { return possible_end_play_signal(e.to_struct()); } } catch (end_turn_exception & e) { return possible_end_play_signal(e.to_struct()); } finish_side_turn(); } player_number_++; if (static_cast<size_t>(player_number_) > gamestate_.board_.teams().size()) { //during the orginal game player_number_ would also be gamestate_.board_.teams().size(), player_number_ = gamestate_.board_.teams().size(); finish_turn(); gamestate_.tod_manager_.next_turn(*resources::gamedata); it_is_a_new_turn_ = true; player_number_ = 1; current_turn_++; gui_->new_turn(); } // This is necessary for replays in order to show possible movements. gamestate_.board_.new_turn(player_number_); update_teams(); update_gui(); return boost::none; }