move player_number_ to game_state

src/game_state.cpp

@@ -52,6 +52,7 @@ game_state::game_state(const config & level, play_controller & pc, const tdata_c
 	reports_(new reports()),
 	lua_kernel_(),
 	events_manager_(),
+	player_number_(level["playing_team"].to_int() + 1),
 	init_side_done_(level["init_side_done"].to_bool(false)),
 	first_human_team_(-1)
 {
@@ -221,6 +222,9 @@ void game_state::set_game_display(game_display * gd)
 void game_state::write(config& cfg) const
 {
 	cfg["init_side_done"] = init_side_done_;
+	if(gamedata_.phase() == game_data::PLAY) {
+		cfg["playing_team"] = player_number_ - 1;
+	}
 
 	//Call the lua save_game functions
 	lua_kernel_->save_game(cfg);

src/game_state.hpp

@@ -52,6 +52,8 @@ class game_state : public filter_context
 	boost::scoped_ptr<reports> reports_;
 	boost::scoped_ptr<game_lua_kernel> lua_kernel_;
 	boost::scoped_ptr<game_events::manager> events_manager_;
+	int player_number_;
+
 	bool init_side_done_;
 	bool& init_side_done() { return init_side_done_; }
 

src/play_controller.cpp

@@ -159,7 +159,6 @@ play_controller::play_controller(const config& level, saved_game& state_of_game,
 	, undo_stack_(new actions::undo_list(level.child("undo_stack")))
 	, replay_(new replay(state_of_game.get_replay()))
 	, loading_game_(!level["playing_team"].empty())
-	, player_number_(level["playing_team"].to_int() + 1)
 	, skip_replay_(skip_replay)
 	, linger_(false)
 	, init_side_done_now_(false)
@@ -358,16 +357,16 @@ void play_controller::init_gui()
 
 void play_controller::init_side_begin()
 {
-	mouse_handler_.set_side(player_number_);
+	mouse_handler_.set_side(current_side());
 
 	// If we are observers we move to watch next team if it is allowed
 	if ((is_observer() && !current_team().get_disallow_observers())
 		|| (current_team().is_local_human() && !this->is_replay())) 
 	{
-		update_gui_to_player(player_number_ - 1);
+		update_gui_to_player(current_side() - 1);
 	}
 
-	gui_->set_playing_team(size_t(player_number_ - 1));
+	gui_->set_playing_team(size_t(current_side() - 1));
 
 	gamestate().gamedata_.last_selected = map_location::null_location();
 }
@@ -403,9 +402,9 @@ void play_controller::do_init_side()
 	init_side_done_now_ = true;
 
 	const std::string turn_num = str_cast(turn());
-	const std::string side_num = str_cast(player_number_);
+	const std::string side_num = str_cast(current_side());
 
-	gamestate().gamedata_.get_variable("side_number") = player_number_;
+	gamestate().gamedata_.get_variable("side_number") = current_side();
 
 	// We might have skipped some sides because they were empty so it is not enough to check for side_num==1
 	if(!gamestate().tod_manager_.has_turn_event_fired())
@@ -425,31 +424,31 @@ void play_controller::do_init_side()
 	// Healing/income happen if it's not the first turn of processing,
 	// or if we are loading a game.
 	if (turn() > 1) {
-		gamestate().board_.new_turn(player_number_);
+		gamestate().board_.new_turn(current_side());
 		current_team().new_turn();
 
 		// If the expense is less than the number of villages owned
 		// times the village support capacity,
 		// then we don't have to pay anything at all
-		int expense = gamestate().board_.side_upkeep(player_number_) -
+		int expense = gamestate().board_.side_upkeep(current_side()) -
 			current_team().support();
 		if(expense > 0) {
 			current_team().spend_gold(expense);
 		}
 
-		calculate_healing(player_number_, !is_skipping_replay());
+		calculate_healing(current_side(), !is_skipping_replay());
 	}
 
 	// Prepare the undo stack.
-	undo_stack_->new_side_turn(player_number_);
+	undo_stack_->new_side_turn(current_side());
 
 	pump().fire("turn refresh");
 	pump().fire("side " + side_num + " turn refresh");
 	pump().fire("turn " + turn_num + " refresh");
 	pump().fire("side " + side_num + " turn " + turn_num + " refresh");
 
 	// Make sure vision is accurate.
-	actions::clear_shroud(player_number_, true);
+	actions::clear_shroud(current_side(), true);
 	init_side_end();
 	check_victory();
 	sync.do_final_checkup();
@@ -458,15 +457,15 @@ void play_controller::init_side_end()
 {
 	const time_of_day &tod = gamestate().tod_manager_.get_time_of_day();
 
-	if (player_number_ == 1 || !init_side_done_now_)
+	if (current_side() == 1 || !init_side_done_now_)
 		sound::play_sound(tod.sounds, sound::SOUND_SOURCES);
 
 	if (!is_skipping_replay()){
 		gui_->invalidate_all();
 	}
 
 	if (!is_skipping_replay() && current_team().get_scroll_to_leader()){
-		gui_->scroll_to_leader(player_number_,game_display::ONSCREEN,false);
+		gui_->scroll_to_leader(current_side(), game_display::ONSCREEN,false);
 	}
 	whiteboard_manager_->on_init_side();
 }
@@ -496,10 +495,6 @@ config play_controller::to_config() const
 	//Write the soundsources.
 	soundsources_manager_->write_sourcespecs(cfg);
 
-	if(resources::gamedata->phase() == game_data::PLAY) {
-		cfg["playing_team"] = player_number_ - 1;
-	}
-
 	if(gui_.get() != NULL) {
 		gui_->labels().write(cfg);
 		sound::write_music_play_list(cfg);
@@ -511,25 +506,25 @@ config play_controller::to_config() const
 void play_controller::finish_side_turn()
 {
 
-	whiteboard_manager_->on_finish_side_turn(player_number_);
+	whiteboard_manager_->on_finish_side_turn(current_side());
 
 	{ //Block for set_scontext_synced
 		set_scontext_synced sync(1);
 		// Ending the turn commits all moves.
 		undo_stack_->clear();
-		gamestate().board_.end_turn(player_number_);
+		gamestate().board_.end_turn(current_side());
 		const std::string turn_num = str_cast(turn());
-		const std::string side_num = str_cast(player_number_);
+		const std::string side_num = str_cast(current_side());
 
 		// Clear shroud, in case units had been slowed for the turn.
-		actions::clear_shroud(player_number_);
+		actions::clear_shroud(current_side());
 
 		pump().fire("side turn end");
 		pump().fire("side "+ side_num + " turn end");
 		pump().fire("side turn " + turn_num + " end");
 		pump().fire("side " + side_num + " turn " + turn_num + " end");
 		// This is where we refog, after all of a side's events are done.
-		actions::recalculate_fog(player_number_);
+		actions::recalculate_fog(current_side());
 		check_victory();	
 		sync.do_final_checkup();
 	}
@@ -572,7 +567,7 @@ void play_controller::enter_textbox()
 	}
 
 	const std::string str = menu_handler_.get_textbox().box()->text();
-	const unsigned int team_num = player_number_;
+	const unsigned int team_num = current_side();
 	events::mouse_handler& mousehandler = mouse_handler_;
 
 	switch(menu_handler_.get_textbox().mode()) {
@@ -648,14 +643,14 @@ void play_controller::tab()
 
 team& play_controller::current_team()
 {
-	assert(player_number_ > 0 && player_number_ <= int(gamestate().board_.teams().size()));
-	return gamestate().board_.teams_[player_number_-1];
+	assert(current_side() > 0 && current_side() <= int(gamestate().board_.teams().size()));
+	return gamestate().board_.teams_[current_side() - 1];
 }
 
 const team& play_controller::current_team() const
 {
-	assert(player_number_ > 0 && player_number_ <= int(gamestate().board_.teams().size()));
-	return gamestate().board_.teams()[player_number_-1];
+	assert(current_side() > 0 && current_side() <= int(gamestate().board_.teams().size()));
+	return gamestate().board_.teams()[current_side() - 1];
 }
 
 /// @returns: the number n in [min, min+mod ) so that (n - num) is a multiple of mod.
@@ -686,12 +681,12 @@ bool play_controller::is_team_visible(int team_num, bool observer) const
 
 int play_controller::find_last_visible_team() const
 {
-	assert(player_number_ <= int(gamestate().board_.teams().size()));
+	assert(current_side() <= int(gamestate().board_.teams().size()));
 	const int num_teams = gamestate().board_.teams().size();
 	const bool is_observer = this->is_observer();
 
 	for(int i = 0; i < num_teams; i++) {
-		const int team_num = modulo(player_number_ - i, num_teams, 1);
+		const int team_num = modulo(current_side() - i, num_teams, 1);
 		if(is_team_visible(team_num, is_observer)) {
 			return team_num;
 		}
@@ -755,7 +750,7 @@ void play_controller::process_keyup_event(const SDL_Event& event) {
 
 			if(u.valid()) {
 				// if it's not the unit's turn, we reset its moves
-				unit_movement_resetter move_reset(*u, u->side() != player_number_);
+				unit_movement_resetter move_reset(*u, u->side() != current_side());
 
 				mouse_handler_.set_current_paths(pathfind::paths(*u, false,
 				                       true, gamestate().board_.teams_[gui_->viewing_team()],
@@ -1107,7 +1102,7 @@ void play_controller::play_side()
 		// This flag can be set by derived classes (in overridden functions).
 		player_type_changed_ = false;
 
-		statistics::reset_turn_stats(gamestate().board_.teams()[player_number_ - 1].save_id());
+		statistics::reset_turn_stats(gamestate().board_.teams()[current_side() - 1].save_id());
 
 		play_side_impl();
 
@@ -1135,7 +1130,7 @@ void play_controller::play_turn()
 		LOG_AIT << "Turn " << turn() << ":" << std::endl;
 	}
 
-	for (; player_number_ <= int(gamestate().board_.teams().size()); ++player_number_)
+	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()) {
@@ -1147,7 +1142,7 @@ void play_controller::play_turn()
 			init_side_end();
 		}
 
-		ai_testing::log_turn_start(player_number_);
+		ai_testing::log_turn_start(current_side());
 		play_side();
 		if(is_regular_game_end()) {
 			return;
@@ -1157,14 +1152,14 @@ void play_controller::play_turn()
 			return;
 		}
 		if(non_interactive()) {
-			LOG_AIT << " Player " << player_number_ << ": " <<
+			LOG_AIT << " Player " << current_side() << ": " <<
 				current_team().villages().size() << " Villages" <<
 				std::endl;
-			ai_testing::log_turn_end(player_number_);
+			ai_testing::log_turn_end(current_side());
 		}
 	}
 	//If the loop exits due to the last team having been processed,
-	player_number_ = gamestate().board_.teams().size();
+	gamestate_->player_number_ = gamestate().board_.teams().size();
 
 	finish_turn();
 

src/play_controller.hpp

@@ -169,7 +169,7 @@ class play_controller : public controller_base, public events::observer, public
 	size_t turn() const {return gamestate().tod_manager_.turn();}
 
 	/** Returns the number of the side whose turn it is. Numbering starts at one. */
-	int current_side() const { return player_number_; }
+	int current_side() const { return gamestate_->player_number_; }
 
 	config to_config() const;
 
@@ -293,7 +293,6 @@ class play_controller : public controller_base, public events::observer, public
 	/// if a team is specified whose turn it is, it means we're loading a game instead of starting a fresh one.
 	bool loading_game_;
 
-	int player_number_;
 	bool skip_replay_;
 	bool linger_;
 	/// whether we did init side in this session ( false = we did init side before we reloaded the game).

src/playmp_controller.cpp

@@ -324,7 +324,7 @@ void playmp_controller::after_human_turn(){
 
 		current_team().set_action_bonus_count(0);
 		current_team().set_countdown_time(new_time);
-		resources::recorder->add_countdown_update(new_time, player_number_);
+		resources::recorder->add_countdown_update(new_time, current_side());
 	}
 	LOG_NG << "playmp::after_human_turn...\n";
 

src/playsingle_controller.cpp

@@ -228,7 +228,7 @@ void playsingle_controller::play_scenario_main_loop()
 		if (is_regular_game_end()) {
 			return;
 		}
-		player_number_ = 1;
+		gamestate_->player_number_ = 1;
 	} //end for loop
 }
 
@@ -387,7 +387,7 @@ void playsingle_controller::play_side_impl()
 		LOG_NG << "is human...\n";
 		// If a side is dead end the turn, but play at least side=1's
 		// turn in case all sides are dead
-		if (gamestate().board_.side_units(player_number_) == 0 && !(gamestate().board_.units().size() == 0 && player_number_ == 1)) {
+		if (gamestate().board_.side_units(current_side()) == 0 && !(gamestate().board_.units().size() == 0 && current_side() == 1)) {
 			end_turn_ = END_TURN_REQUIRED;
 		}
 
@@ -444,7 +444,7 @@ void playsingle_controller::show_turn_dialog(){
 		gui_->recalculate_minimap();
 		std::string message = _("It is now $name|’s turn");
 		utils::string_map symbols;
-		symbols["name"] = gamestate().board_.teams()[player_number_ - 1].current_player();
+		symbols["name"] = gamestate().board_.teams()[current_side() - 1].current_player();
 		message = utils::interpolate_variables_into_string(message, &symbols);
 		gui2::show_transient_message(gui_->video(), "", message);
 	}
@@ -458,7 +458,7 @@ void playsingle_controller::execute_gotos()
 	}
 	try
 	{
-		menu_handler_.execute_gotos(mouse_handler_, player_number_);
+		menu_handler_.execute_gotos(mouse_handler_, current_side());
 	}
 	catch (const return_to_play_side_exception&)
 	{
@@ -560,7 +560,7 @@ void playsingle_controller::play_ai_turn()
 	turn_data_.send_data();
 	try {
 		try {
-			ai::manager::play_turn(player_number_);
+			ai::manager::play_turn(current_side());
 		}
 		catch (return_to_play_side_exception&) {
 		}
@@ -616,7 +616,7 @@ void playsingle_controller::handle_generic_event(const std::string& name){
 void playsingle_controller::end_turn(){
 	if (linger_)
 		end_turn_ = END_TURN_REQUIRED;
-	else if (!is_browsing() && menu_handler_.end_turn(player_number_)){
+	else if (!is_browsing() && menu_handler_.end_turn(current_side())){
 		end_turn_ = END_TURN_REQUIRED;
 	}
 }

src/replay_controller.cpp

@@ -142,7 +142,7 @@ void replay_controller::main_loop(bool is_unit_test)
 				if (is_regular_game_end()) {
 					return;
 				}
-				player_number_ = 1;
+				gamestate_->player_number_ = 1;
 			}
 			while(true) {
 				//lingering
@@ -201,7 +201,7 @@ void replay_controller::init_gui()
 	play_controller::init_gui();
 
 	gui_->set_team(vision_ == HUMAN_TEAM ? gamestate().first_human_team_ : 0, vision_ == SHOW_ALL);
-	gui_->scroll_to_leader(player_number_, display::WARP);
+	gui_->scroll_to_leader(current_side(), display::WARP);
 	update_locker lock_display((*gui_).video(),false);
 	BOOST_FOREACH(const team & t, gamestate().board_.teams()) {
 		t.reset_objectives_changed();
@@ -359,7 +359,7 @@ void replay_controller::reset_replay_impl()
 	DBG_REPLAY << "replay_controller::reset_replay\n";
 
 	gui_->get_chat_manager().clear_chat_messages();
-	player_number_ = level_["playing_team"].to_int() + 1;
+	gamestate_->player_number_ = level_["playing_team"].to_int() + 1;
 	gamestate_->init_side_done() = level_["init_side_done"].to_bool(false);
 	skip_replay_ = false;
 	gamestate().tod_manager_= tod_manager_start_;
@@ -417,7 +417,7 @@ void replay_controller::replay_next_turn()
 
 void replay_controller::replay_next_side()
 {
-	stop_condition_.reset(new replay_play_side(gamestate().tod_manager_.turn(), player_number_));
+	stop_condition_.reset(new replay_play_side(gamestate().tod_manager_.turn(), current_side()));
 }
 
 void replay_controller::replay_next_move()
@@ -479,7 +479,7 @@ void replay_controller::play_replay()
 
 void replay_controller::update_teams()
 {
-	int next_team = player_number_;
+	int next_team = current_side();
 	if(static_cast<size_t>(next_team) > gamestate().board_.teams().size()) {
 		next_team = 1;
 	}
@@ -522,7 +522,7 @@ bool replay_controller::recorder_at_end() {
 void replay_controller::play_side_impl()
 {
 	update_teams();
-	stop_condition_->new_side_turn(player_number_, gamestate().tod_manager_.turn());
+	stop_condition_->new_side_turn(current_side(), gamestate().tod_manager_.turn());
 	while(true)
 	{
 		if(!stop_condition_->should_stop())