0ct0pu5/wesnoth
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

move player_number_ to game_state

Browse source
This commit is contained in:
gfgtdf 2015-09-09 14:51:15 +00:00
parent 8e875b8458
commit 941f00e491
7 changed files with 51 additions and 51 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/game_state.cpp
View file

@ -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);

2
src/game_state.hpp
View file

@ -52,6 +52,8 @@ public:
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_; }

67
src/play_controller.cpp
View file

@ -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,23 +424,23 @@ 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");
@ -449,7 +448,7 @@ void play_controller::do_init_side()
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,7 +457,7 @@ 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()){
@ -466,7 +465,7 @@ void play_controller::init_side_end()
}
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();

3
src/play_controller.hpp
View file

@ -169,7 +169,7 @@ 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 @@ protected:
/// 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).

2
src/playmp_controller.cpp
View file

@ -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";

12
src/playsingle_controller.cpp
View file

@ -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;
}
}

12
src/replay_controller.cpp
View file

@ -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())