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 playsingle_controller::check_time_over(){
bool time_left = gamestate_.tod_manager_.next_turn(gamestate_.gamedata_);
it_is_a_new_turn_ = true;
if(!time_left) {
LOG_NG << "firing time over event...\n";
set_scontext_synced_base sync;
pump().fire("time over");
LOG_NG << "done firing time over event...\n";
//if turns are added while handling 'time over' event
if (gamestate_.tod_manager_.is_time_left()) {
return;
}
if(non_interactive()) {
LOG_AIT << "time over (draw)\n";
ai_testing::log_draw();
}
check_victory();
if (is_regular_game_end()) {
return;
}
end_level_data e;
e.proceed_to_next_level = false;
e.is_victory = false;
set_end_level_data(e);
}
}
possible_end_play_signal playsingle_controller::check_time_over() {
bool b = gamestate_.tod_manager_.next_turn(*resources::gamedata);
it_is_a_new_turn_ = true;
if(!b) {
LOG_NG << "firing time over event...\n";
game_events::fire("time over");
LOG_NG << "done firing time over event...\n";
//if turns are added while handling 'time over' event
if (gamestate_.tod_manager_.is_time_left()) {
return boost::none;
}
if(non_interactive()) {
LOG_AIT << "time over (draw)\n";
ai_testing::log_draw();
}
HANDLE_END_PLAY_SIGNAL( check_victory() );
get_end_level_data().proceed_to_next_level = false;
end_level_struct els = {DEFEAT};
return possible_end_play_signal (els);
//throw end_level_exception(DEFEAT);
}
return boost::none;
}
bool turbo()
{
if(non_interactive()) {
return true;
}
return get("turbo", false);
}
bool turbo()
{
if(non_interactive()) {
return true;
}
return utils::string_bool(get("turbo"), false);
}
int main (){
prev_usr_milliseconds = 0;
prev_sys_milliseconds = 0;
prev_stats.ru_nivcsw = 0;
prev_stats.ru_nvcsw = 0;
prev_stats.ru_majflt = 0;
prev_stats.ru_minflt = 0;
if (isatty(STDIN_FILENO)==0){
non_interactive();
}
else {
interactive();
}
// free(params);
}
void replay_controller::process_oos(const std::string& msg) const
{
if (game_config::ignore_replay_errors) {
return;
}
std::stringstream message;
message << _("The replay is corrupt/out of sync. It might not make much sense to continue. Do you want to save the game?");
message << "\n\n" << _("Error details:") << "\n\n" << msg;
if (non_interactive()) {
throw game::game_error(message.str()); //throw end_level_exception(DEFEAT);
} else {
savegame::oos_savegame save(saved_game_, *gui_, to_config());
save.save_game_interactive(resources::screen->video(), message.str(), gui::YES_NO); // can throw end_level_exception
}
}
void playsingle_controller::check_time_over(){
bool b = tod_manager_.next_turn();
it_is_a_new_turn_ = true;
if(!b) {
LOG_NG << "firing time over event...\n";
game_events::fire("time over");
LOG_NG << "done firing time over event...\n";
//if turns are added while handling 'time over' event
if (tod_manager_.is_time_left()) {
return;
}
if(non_interactive()) {
std::cout << "time over (draw)\n";
ai_testing::log_draw();
}
check_end_level();
throw end_level_exception(DEFEAT);
}
}
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;
}
