fix [end_turn] in networked mp

this was broken in a previous refactoring commit of me as reported in
https://gna.org/bugs/?23349.

src/play_controller.hpp

@@ -175,7 +175,6 @@ class play_controller : public controller_base, public events::observer, public
 
 	bool is_skipping_replay() const { return skip_replay_;}
 	bool is_linger_mode() const { return linger_; }
-	virtual bool is_end_turn() const { return false; }
 	void do_autosave();
 
 	void do_consolesave(const std::string& filename);

src/playmp_controller.cpp

@@ -111,7 +111,7 @@ void playmp_controller::play_linger_turn()
 		end_turn_enable(true);
 	}
 
-	while(!end_turn_) {
+	while(end_turn_ == END_TURN_NONE) {
 		config cfg;
 		if(network_reader_.read(cfg)) {
 			if(turn_data_.process_network_data(cfg) == turn_info::PROCESS_END_LINGER)
@@ -177,7 +177,7 @@ void playmp_controller::play_human_turn()
 				bool time_left = timer->update();
 				if(!time_left)
 				{
-					end_turn_ = true;
+					end_turn_ = END_TURN_REQUIRED;
 				}
 			}
 		}
@@ -261,7 +261,7 @@ void playmp_controller::linger()
 			// reimplement parts of play_side()
 			player_number_ = first_player_;
 			turn_data_.send_data();
-			end_turn_ = false;
+			end_turn_ = END_TURN_NONE;
 			play_linger_turn();
 			after_human_turn();
 			LOG_NG << "finished human turn" << std::endl;
@@ -344,7 +344,7 @@ void playmp_controller::play_network_turn(){
 	end_turn_enable(false);
 	turn_data_.send_data();
 
-	while(!should_return_to_play_side())
+	while(end_turn_ != END_TURN_SYNCED && !is_regular_game_end() && !player_type_changed_)
 	{
 		if (!network_processing_stopped_) {
 			process_network_data();
@@ -466,7 +466,7 @@ void playmp_controller::process_network_data()
 		player_type_changed_ = true;
 	}
 	else if (res == turn_info::PROCESS_END_TURN) {
-		end_turn_ = true;
+		end_turn_ = END_TURN_SYNCED;
 	}
 	else if (res == turn_info::PROCESS_END_LEVEL) {
 	}

src/playsingle_controller.cpp

@@ -79,7 +79,7 @@ playsingle_controller::playsingle_controller(const config& level,
 	, replay_sender_(recorder)
 	, network_reader_()
 	, turn_data_(replay_sender_, network_reader_)
-	, end_turn_(false)
+	, end_turn_(END_TURN_NONE)
 	, player_type_changed_(false)
 	, skip_next_turn_(false)
 	, do_autosaves_(false)
@@ -505,7 +505,7 @@ void playsingle_controller::play_side()
 		// This flag can be set by derived classes (in overridden functions).
 		player_type_changed_ = false;
 		if (!skip_next_turn_)
-			end_turn_ = false;
+			end_turn_ = END_TURN_NONE;
 
 		statistics::reset_turn_stats(gamestate_.board_.teams()[player_number_ - 1].save_id());
 
@@ -518,16 +518,18 @@ void playsingle_controller::play_side()
 				|| (gamestate_.board_.units().size() == 0 && player_number_ == 1))
 			{
 				before_human_turn();
-				if (!end_turn_) {
+				if (end_turn_ == END_TURN_NONE) {
 					play_human_turn();
 					if(is_regular_game_end()) {
 						return;
 					}
 				}
 			}
 
-			if ( !player_type_changed_ )
+			if ( !player_type_changed_ ) {
+				sync_end_turn();
 				after_human_turn();
+			}
 			LOG_NG << "human finished turn...\n";
 
 		} else if(current_team().is_local_ai() || (current_team().is_local_human() && current_team().is_droid())) {
@@ -543,7 +545,7 @@ void playsingle_controller::play_side()
 			}
 			if(!player_type_changed_)
 			{
-				recorder.end_turn();
+				sync_end_turn();
 			}
 
 		} else if(current_team().is_network()) {
@@ -555,7 +557,7 @@ void playsingle_controller::play_side()
 			end_turn_enable(false);
 			do_idle_notification();
 			before_human_turn();
-			if (!end_turn_) {
+			if (end_turn_ == END_TURN_NONE) {
 				play_idle_loop();
 				if(is_regular_game_end()) {
 					return;
@@ -569,14 +571,15 @@ void playsingle_controller::play_side()
 	} while (player_type_changed_);
 	// Keep looping if the type of a team (human/ai/networked)
 	// has changed mid-turn
+	assert(end_turn_ == END_TURN_SYNCED);
 	skip_next_turn_ = false;
 }
 
 void playsingle_controller::before_human_turn()
 {
 	log_scope("player turn");
 	linger_ = false;
-	if(end_turn_) {
+	if(end_turn_ != END_TURN_NONE) {
 		return;
 	}
 	//TODO: why do we need the next line?
@@ -656,8 +659,8 @@ void playsingle_controller::linger()
 		// Same logic as single-player human turn, but
 		// *not* the same as multiplayer human turn.
 		end_turn_enable(true);
-		end_turn_ = false;
-		while(!end_turn_) {
+		end_turn_ = END_TURN_NONE;
+		while(end_turn_ == END_TURN_NONE) {
 			// Reset the team number to make sure we're the right team.
 			player_number_ = first_player_;
 			play_slice();
@@ -689,12 +692,6 @@ void playsingle_controller::end_turn_enable(bool enable)
 
 void playsingle_controller::after_human_turn()
 {
-	// Mark the turn as done.
-	if (!linger_)
-	{
-		recorder.end_turn();
-	}
-
 	// Clear moves from the GUI.
 	gui_->set_route(NULL);
 	gui_->unhighlight_reach();
@@ -799,15 +796,15 @@ void playsingle_controller::check_time_over(){
 
 void playsingle_controller::end_turn(){
 	if (linger_)
-		end_turn_ = true;
-	else if (!is_browsing()){
-		end_turn_ = menu_handler_.end_turn(player_number_);
+		end_turn_ = END_TURN_REQUIRED;
+	else if (!is_browsing() && menu_handler_.end_turn(player_number_)){
+		end_turn_ = END_TURN_REQUIRED;
 	}
 }
 
 void playsingle_controller::force_end_turn(){
 	skip_next_turn_ = true;
-	end_turn_ = true;
+	end_turn_ = END_TURN_REQUIRED;
 }
 
 void playsingle_controller::check_objectives()
@@ -834,3 +831,14 @@ void playsingle_controller::maybe_linger()
 		linger();
 	}
 }
+
+void playsingle_controller::sync_end_turn()
+{
+	//We cannot add [end_turn] to the recorder while executing another action.
+	assert(synced_context::synced_state() == synced_context::UNSYNCED);
+	if(end_turn_ == END_TURN_REQUIRED && current_team().is_local())
+	{
+		recorder.end_turn();
+		end_turn_ = END_TURN_SYNCED;
+	}
+}

src/playsingle_controller.hpp

@@ -49,13 +49,12 @@ class playsingle_controller : public play_controller
 	void force_end_turn();
 
 	class hotkey_handler;
-	virtual bool is_end_turn() const { return end_turn_; }
 	std::string describe_result() const;
 
 	bool get_player_type_changed() const { return player_type_changed_; }
 	void set_player_type_changed() { player_type_changed_ = true; }
 	virtual bool should_return_to_play_side()
-	{ return player_type_changed_ || end_turn_ || is_regular_game_end(); }
+	{ return player_type_changed_ || end_turn_ != END_TURN_NONE || is_regular_game_end(); }
 protected:
 	void play_turn();
 	virtual void play_side();
@@ -80,11 +79,21 @@ class playsingle_controller : public play_controller
 	replay_network_sender replay_sender_;
 	playturn_network_adapter network_reader_;
 	turn_info turn_data_;
-	bool end_turn_;
+	enum END_TURN_STATE
+	{
+		/// The turn was not ended yet
+		END_TURN_NONE,
+		/// And endturn was required eigher by the player, by the ai or by [end_turn]
+		END_TURN_REQUIRED,
+		/// An [end_turn] was added to the replay.
+		END_TURN_SYNCED,
+	};
+	END_TURN_STATE end_turn_;
 	bool player_type_changed_;
 	bool skip_next_turn_;
 	bool do_autosaves_;
 	void linger();
+	void sync_end_turn();
 };