void playmp_controller::play_network_turn(){
LOG_NG << "is networked...\n";
end_turn_enable(false);
turn_data_.send_data();
while(end_turn_ != END_TURN_SYNCED && !is_regular_game_end() && !player_type_changed_)
{
if (!network_processing_stopped_) {
process_network_data();
if (!mp_info_ || mp_info_->skip_replay_until_turn > 0) {
skip_replay_ = false;
}
}
play_slice_catch();
if (!network_processing_stopped_){
turn_data_.send_data();
}
gui_->draw();
}
LOG_NG << "finished networked...\n";
}
void tlobby_main::network_handler()
{
if(gamelist_dirty_ && !delay_gamelist_update_
&& (SDL_GetTicks() - last_gamelist_update_
> game_config::lobby_refresh)) {
if(gamelist_diff_update_) {
update_gamelist_diff();
} else {
update_gamelist();
gamelist_diff_update_ = true;
}
}
if(player_list_dirty_) {
update_gamelist_filter();
update_playerlist();
}
try {
config data;
if(wesnothd_connection_.receive_data(data)) {
process_network_data(data);
}
} catch(wesnothd_error& e) {
LOG_LB << "caught wesnothd_error in network_handler: " << e.message
<< "\n";
throw;
}
}
void playmp_controller::play_slice(bool is_delay_enabled)
{
if(!linger_ && !is_replay()) {
//receive chat during animations and delay
process_network_data(true);
//cannot use turn_data_.send_data() here.
replay_sender_.sync_non_undoable();
}
playsingle_controller::play_slice(is_delay_enabled);
}
turn_info::PROCESS_DATA_RESULT turn_info::process_network_data_from_reader()
{
config cfg;
while(this->network_reader_.read(cfg))
{
PROCESS_DATA_RESULT res = process_network_data(cfg);
if(res != PROCESS_CONTINUE)
{
return res;
}
cfg.clear();
}
return PROCESS_CONTINUE;
}
void turn_info::sync_network()
{
if(network::nconnections() > 0) {
//receive data first, and then send data. When we sent the end of
//the AI's turn, we don't want there to be any chance where we
//could get data back pertaining to the next turn.
config cfg;
while(network::connection res = network::receive_data(cfg)) {
std::deque<config> backlog;
process_network_data(cfg,res,backlog,false);
cfg.clear();
}
send_data();
}
}
turn_info::PROCESS_DATA_RESULT turn_info::sync_network()
{
//there should be nothing left on the replay and we should get turn_info::PROCESS_CONTINUE back.
turn_info::PROCESS_DATA_RESULT retv = replay_to_process_data_result(do_replay());
if(resources::controller->is_networked_mp()) {
//receive data first, and then send data. When we sent the end of
//the AI's turn, we don't want there to be any chance where we
//could get data back pertaining to the next turn.
config cfg;
while( (retv == turn_info::PROCESS_CONTINUE) && network_reader_.read(cfg)) {
retv = process_network_data(cfg);
cfg.clear();
}
send_data();
}
return retv;
}
void playmp_controller::play_idle_loop()
{
LOG_NG << "playmp::play_human_turn...\n";
remove_blindfold();
while (!should_return_to_play_side())
{
try
{
process_network_data();
play_slice_catch();
SDL_Delay(1);
}
catch(...)
{
turn_data_.send_data();
throw;
}
turn_data_.send_data();
}
}
void playmp_controller::play_human_turn()
{
LOG_NG << "playmp::play_human_turn...\n";
assert(!linger_);
assert(gamestate_->init_side_done());
assert(gamestate().gamedata_.phase() == game_data::PLAY);
mp_ui_alerts::turn_changed(current_team().current_player());
LOG_NG << "events::commands_disabled=" << events::commands_disabled <<"\n";
remove_blindfold();
const std::unique_ptr<countdown_clock> timer(saved_game_.mp_settings().mp_countdown
? new countdown_clock(current_team())
: nullptr);
show_turn_dialog();
if(undo_stack().can_undo()) {
// If we reload a networked mp game we cannot undo moves made before the save
// because other players already received them
if(!current_team().auto_shroud_updates()) {
synced_context::run_and_store("update_shroud", replay_helper::get_update_shroud());
}
undo_stack().clear();
}
if (!preferences::disable_auto_moves()) {
execute_gotos();
}
end_turn_enable(true);
while(!should_return_to_play_side()) {
try {
process_network_data();
check_objectives();
play_slice_catch();
if (player_type_changed_)
{
// Clean undo stack if turn has to be restarted (losing control)
if ( undo_stack().can_undo() )
{
font::floating_label flabel(_("Undoing moves not yet transmitted to the server."));
color_t color {255,255,255,SDL_ALPHA_OPAQUE};
flabel.set_color(color);
SDL_Rect rect = gui_->map_area();
flabel.set_position(rect.w/2, rect.h/2);
flabel.set_lifetime(150);
flabel.set_clip_rect(rect);
font::add_floating_label(flabel);
}
while( undo_stack().can_undo() )
undo_stack().undo();
}
if(timer)
{
bool time_left = timer->update();
if(!time_left)
{
end_turn_ = END_TURN_REQUIRED;
}
}
}
catch(...)
{
turn_data_.send_data();
throw;
}
turn_data_.send_data();
}
}
void playmp_controller::play_human_turn()
{
LOG_NG << "playmp::play_human_turn...\n";
assert(!linger_);
remove_blindfold();
boost::scoped_ptr<countdown_clock> timer;
if(saved_game_.mp_settings().mp_countdown) {
timer.reset(new countdown_clock(current_team()));
}
show_turn_dialog();
if(undo_stack_->can_undo()) {
// If we reload a networked mp game we cannot undo moves made before the save
// Becasue other players already received them
if(!current_team().auto_shroud_updates()) {
synced_context::run_and_store("update_shroud", replay_helper::get_update_shroud());
}
undo_stack_->clear();
}
if (!preferences::disable_auto_moves()) {
execute_gotos();
}
end_turn_enable(true);
while(!should_return_to_play_side()) {
try {
process_network_data();
if (player_type_changed_)
{
// Clean undo stack if turn has to be restarted (losing control)
if ( undo_stack_->can_undo() )
{
font::floating_label flabel(_("Undoing moves not yet transmitted to the server."));
SDL_Color color = {255,255,255,255};
flabel.set_color(color);
SDL_Rect rect = gui_->map_area();
flabel.set_position(rect.w/2, rect.h/2);
flabel.set_lifetime(150);
flabel.set_clip_rect(rect);
font::add_floating_label(flabel);
}
while( undo_stack_->can_undo() )
undo_stack_->undo();
}
check_objectives();
play_slice_catch();
if(timer)
{
bool time_left = timer->update();
if(!time_left)
{
end_turn_ = END_TURN_REQUIRED;
}
}
}
catch(...)
{
turn_data_.send_data();
throw;
}
turn_data_.send_data();
gui_->draw();
}
}
