upstream/wesnoth
1
0
Fork 0
mirror of https://github.com/wesnoth/wesnoth synced 2025-05-14 16:49:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

make saved_game::carryoves_sides(_start) private

Browse Source
This commit is contained in:
gfgtdf 2014-07-30 16:47:23 +02:00
parent 5bfe04259d
commit 35e1391652
7 changed files with 104 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/game_launcher.cpp
View File

@ -18,6 +18,7 @@
#include "about.hpp" //for show_about
#include "commandline_options.hpp" // for commandline_options
#include "config.hpp" // for config, etc
#include "config_assign.hpp"
#include "construct_dialog.hpp" // for dialog
#include "cursor.hpp" // for set, CURSOR_TYPE::NORMAL
#include "exceptions.hpp" // for error
@ -451,9 +452,14 @@ bool game_launcher::play_test()
first_time = false;
state_.classification().campaign_type = game_classification::TEST;
state_.carryover_sides_start["next_scenario"] = test_scenario_;
state_.classification().campaign_define = "TEST";
state_.set_carryover_sides_start(
config_of("next_scenario", test_scenario_)
);
resources::config_manager->
load_game_config_for_game(state_.classification());
@ -480,8 +486,11 @@ int game_launcher::unit_test()
first_time_unit = false;
state_.classification().campaign_type = game_classification::TEST;
state_.carryover_sides_start["next_scenario"] = test_scenario_;
state_.classification().campaign_define = "TEST";
state_.set_carryover_sides_start(
config_of("next_scenario", test_scenario_)
);
resources::config_manager->
load_game_config_for_game(state_.classification());
@ -674,8 +683,11 @@ void game_launcher::set_tutorial()
{
state_ = saved_game();
state_.classification().campaign_type = game_classification::TUTORIAL;
state_.carryover_sides_start["next_scenario"] = "tutorial";
state_.classification().campaign_define = "TUTORIAL";
state_.set_carryover_sides_start(
config_of("next_scenario", "tutorial")
);
}
void game_launcher::mark_completed_campaigns(std::vector<config> &campaigns)

9
src/mp_game_utils.cpp
View File

@ -67,13 +67,8 @@ config initial_level_config(saved_game& state)
config& scenario = state.get_starting_pos();
if(!state.mp_settings().saved_game)
{
if(state.carryover_sides_start["random_seed"].str() == "")
{
state.carryover_sides_start["random_seed"] = rand();
state.carryover_sides_start["random_calls"] = 0;
}
scenario["turns"] = params.num_turns;
state.set_random_seed();
if (params.random_start_time)
{
if (!tod_manager::is_start_ToD(scenario["random_start_time"]))

10
src/playcampaign.cpp
View File

@ -342,7 +342,7 @@ LEVEL_RESULT play_game(game_display& disp, saved_game& gamestate,
// On DEFEAT, QUIT, or OBSERVER_END, we're done now
//If there is no next scenario we're done now.
if(!end_level.proceed_to_next_level || gamestate.carryover_sides_start["next_scenario"].empty())
if(!end_level.proceed_to_next_level || gamestate.get_scenario_id().empty())
{
return res;
}
@ -381,8 +381,8 @@ LEVEL_RESULT play_game(game_display& disp, saved_game& gamestate,
//then we have to move "allow_new_game" attribute over now.
bool allow_new_game_flag = starting_pos["allow_new_game"].to_bool(true);
if (gamestate.carryover_sides_start.child_or_empty("end_level_data").child_or_empty("next_scenario_settings").has_attribute("allow_new_game")) {
allow_new_game_flag = gamestate.carryover_sides_start.child_or_empty("end_level_data").child("next_scenario_settings")["allow_new_game"].to_bool();
if (gamestate.carryover().child_or_empty("end_level_data").child_or_empty("next_scenario_settings").has_attribute("allow_new_game")) {
allow_new_game_flag = gamestate.carryover().child_or_empty("end_level_data").child("next_scenario_settings")["allow_new_game"].to_bool();
}
gamestate.mp_settings().num_turns = starting_pos["turns"].to_int(-1);
@ -439,10 +439,10 @@ LEVEL_RESULT play_game(game_display& disp, saved_game& gamestate,
}
}
if (!gamestate.carryover_sides_start["next_scenario"].empty() && gamestate.carryover_sides_start["next_scenario"] != "null") {
if (!gamestate.get_scenario_id().empty() && gamestate.get_scenario_id() != "null") {
std::string message = _("Unknown scenario: '$scenario|'");
utils::string_map symbols;
symbols["scenario"] = gamestate.carryover_sides_start["next_scenario"];
symbols["scenario"] = gamestate.get_scenario_id();
message = utils::interpolate_variables_into_string(message, &symbols);
gui2::show_error_message(disp.video(), message);
return QUIT;

92
src/saved_game.cpp
View File

@ -58,8 +58,8 @@ static lg::log_domain log_engine("engine");
saved_game::saved_game()
: replay_data()
, carryover_sides()
, carryover_sides_start(carryover_info().to_config())
, carryover_sides_()
, carryover_sides_start_(carryover_info().to_config())
, replay_start_()
, classification_()
, mp_settings_()
@ -71,8 +71,8 @@ saved_game::saved_game()
saved_game::saved_game(const config& cfg)
: replay_data()
, carryover_sides()
, carryover_sides_start()
, carryover_sides_()
, carryover_sides_start_()
, replay_start_()
, classification_(cfg)
, mp_settings_(cfg)
@ -82,8 +82,8 @@ saved_game::saved_game(const config& cfg)
{
log_scope("read_game");
carryover_sides = cfg.child_or_empty("carryover_sides");
carryover_sides_start = cfg.child_or_empty("carryover_sides_start");
carryover_sides_ = cfg.child_or_empty("carryover_sides");
carryover_sides_start_ = cfg.child_or_empty("carryover_sides_start");
//Serversided replays can contain multiple [replay]
replay_start_ = cfg.child_or_empty("replay_start");
@ -104,16 +104,16 @@ saved_game::saved_game(const config& cfg)
this->starting_pos_ = scenario;
}
if(starting_pos_.empty() && replay_start_.empty() && carryover_sides_start.empty() && !carryover_sides.empty())
if(starting_pos_.empty() && replay_start_.empty() && carryover_sides_start_.empty() && !carryover_sides_.empty())
{
//Explain me: when could this happen?
//if we are loading a start of scenario save and don't have carryover_sides_start, use carryover_sides
//TODO: move this code to convert_old_saves
carryover_sides_start = carryover_sides;
carryover_sides = config();
carryover_sides_start_ = carryover_sides_;
carryover_sides_ = config();
}
LOG_NG << "scenario: '" << carryover_sides_start["next_scenario"].str() << "'\n";
LOG_NG << "scenario: '" << carryover_sides_start_["next_scenario"].str() << "'\n";
if (const config &stats = cfg.child("statistics")) {
statistics::fresh_stats();
@ -124,8 +124,8 @@ saved_game::saved_game(const config& cfg)
saved_game::saved_game(const saved_game& state)
: replay_data(state.replay_data)
, carryover_sides(state.carryover_sides)
, carryover_sides_start(state.carryover_sides_start)
, carryover_sides_(state.carryover_sides_)
, carryover_sides_start_(state.carryover_sides_start_)
, replay_start_(state.replay_start_)
, classification_(state.classification_)
, mp_settings_(state.mp_settings_)
@ -144,6 +144,22 @@ saved_game& saved_game::operator=(const saved_game& state)
return *this ;
}
void saved_game::set_carryover_sides_start(config carryover_sides_start)
{
carryover_sides_start_.swap(carryover_sides_start);
carryover_sides_start_.child_or_add("variables");
}
void saved_game::set_random_seed()
{
if(carryover_sides_start_.empty() || carryover_sides_start_["random_seed"].empty())
{
return;
}
carryover_sides_start_["random_seed"] = rand();
carryover_sides_start_["random_calls"] = 0;
}
void saved_game::write_config(config_writer& out) const
{
write_general_info(out);
@ -173,13 +189,13 @@ void saved_game::write_starting_pos(config_writer& out) const
void saved_game::write_carryover(config_writer& out) const
{
assert(not_corrupt());
if(!this->carryover_sides.empty())
if(!carryover_sides_.empty())
{
out.write_child("carryover_sides", carryover_sides);
out.write_child("carryover_sides", carryover_sides_);
}
if(!this->carryover_sides_start.empty())
if(!carryover_sides_start_.empty())
{
out.write_child("carryover_sides_start", carryover_sides_start);
out.write_child("carryover_sides_start", carryover_sides_start_);
}
}
@ -195,14 +211,14 @@ void saved_game::write_general_info(config_writer& out) const
void saved_game::expand_scenario()
{
if(this->starting_pos_type_ == STARTINGPOS_NONE && !this->carryover_sides_start.empty())
if(this->starting_pos_type_ == STARTINGPOS_NONE && !carryover_sides_start_.empty())
{
resources::config_manager->load_game_config_for_game(this->classification());
const config& game_config = resources::config_manager->game_config();
const config& scenario = game_config.find_child(lexical_cast_default<std::string>
(classification().campaign_type == game_classification::SCENARIO ?
game_classification::MULTIPLAYER : classification().campaign_type),
"id", carryover_sides_start["next_scenario"]);
"id", carryover_sides_start_["next_scenario"]);
if(scenario)
{
this->starting_pos_type_ = STARTINGPOS_SCENARIO;
@ -288,7 +304,7 @@ void saved_game::expand_mp_events()
void saved_game::expand_mp_options()
{
if(this->starting_pos_type_ == STARTINGPOS_SCENARIO && !this->carryover_sides_start.empty())
if(starting_pos_type_ == STARTINGPOS_SCENARIO && !carryover_sides_start_.empty())
{
std::vector<modevents_entry> mods;
@ -298,7 +314,7 @@ void saved_game::expand_mp_options()
mods.push_back(modevents_entry("era", mp_settings_.mp_era));
mods.push_back(modevents_entry("multiplayer", get_scenario_id()));
config& variables = this->carryover_sides_start.child_or_add("variables");
config& variables = carryover_sides_start_.child_or_add("variables");
BOOST_FOREACH(modevents_entry& mod, mods)
{
if(const config& cfg = this->mp_settings().options.find_child(mod.type, "id", mod.id))
@ -357,17 +373,17 @@ void saved_game::expand_random_scenario()
void saved_game::expand_carryover()
{
expand_scenario();
if(this->starting_pos_type_ == STARTINGPOS_SCENARIO && !this->carryover_sides_start.empty())
if(this->starting_pos_type_ == STARTINGPOS_SCENARIO && !carryover_sides_start_.empty())
{
carryover_info sides(carryover_sides_start);
carryover_info sides(carryover_sides_start_);
sides.transfer_to(get_starting_pos());
BOOST_FOREACH(config& side_cfg, get_starting_pos().child_range("side")){
sides.transfer_all_to(side_cfg);
}
carryover_sides = sides.to_config();
carryover_sides_start = config();
carryover_sides_ = sides.to_config();
carryover_sides_start_ = config();
}
}
@ -387,9 +403,9 @@ void saved_game::set_scenario(const config& scenario)
this->starting_pos_type_ = STARTINGPOS_SCENARIO;
this->starting_pos_ = scenario;
//By default we treat the game as 'carryover not expanded yet'
if(this->carryover_sides.empty())
if(carryover_sides_.empty())
{
this->carryover_sides_start.child_or_add("variables");
carryover_sides_start_.child_or_add("variables");
}
update_label();
}
@ -408,11 +424,11 @@ config& saved_game::get_starting_pos()
const config& saved_game::get_replay_starting_pos()
{
if(!this->replay_start_.empty())
if(!replay_start_.empty())
{
return replay_start_;
}
if(!this->carryover_sides_start.empty())
if(!carryover_sides_start_.empty())
{
//Try to load the scenario form game config or from [scenario] if there is no [replay_start]
expand_scenario();
@ -429,12 +445,12 @@ void saved_game::convert_to_start_save()
{
assert(starting_pos_type_ == STARTINGPOS_SNAPSHOT);
carryover_info sides(starting_pos_, true);
sides.merge_old_carryover(carryover_info(carryover_sides));
sides.merge_old_carryover(carryover_info(carryover_sides_));
sides.rng().rotate_random();
carryover_sides_start = sides.to_config();
carryover_sides_start_ = sides.to_config();
replay_data = config();
replay_start_ = config();
carryover_sides = config();
carryover_sides_ = config();
remove_snapshot();
}
@ -458,13 +474,13 @@ config saved_game::to_config() const
{
r.add_child("scenario", starting_pos_);
}
if(!this->carryover_sides.empty())
if(!carryover_sides_.empty())
{
r.add_child("carryover_sides", carryover_sides);
r.add_child("carryover_sides", carryover_sides_);
}
if(!this->carryover_sides_start.empty())
if(!carryover_sides_start_.empty())
{
r.add_child("carryover_sides_start", carryover_sides_start);
r.add_child("carryover_sides_start", carryover_sides_start_);
}
if (classification_.campaign_type == game_classification::MULTIPLAYER) {
@ -482,13 +498,13 @@ std::string saved_game::get_scenario_id()
}
else
{
return carryover_sides_start["next_scenario"];
return carryover_sides_start_["next_scenario"];
}
}
bool saved_game::not_corrupt() const
{
if(carryover_sides.empty() && carryover_sides_start.empty())
if(carryover_sides_.empty() && carryover_sides_start_.empty())
{
//this case is dangerous but currently not impossible.
WRN_NG << "savefile contains neigher [carryover_sides] not [carryover_sides_start]" << std::endl;
@ -498,7 +514,7 @@ bool saved_game::not_corrupt() const
// the function expand_carryover transforms a start of scenario save to a normal save
// the function convert_to_start_save converts a normal save form teh end of the scenaio
// to a start-of-scenario save for a next level
bool r = carryover_sides.empty() || carryover_sides_start.empty();
bool r = carryover_sides_.empty() || carryover_sides_start_.empty();
if(!r)
{
config c = this->to_config();

16
src/saved_game.hpp
View File

@ -41,6 +41,10 @@ public:
/** Multiplayer parameters for this game */
mp_game_settings& mp_settings() { return mp_settings_; }
const mp_game_settings& mp_settings() const { return mp_settings_; }
void set_carryover_sides_start(config carryover_sides_start);
const config& carryover() { return carryover_sides_start_; }
/// copies the content of a [scenario] with the correct id attribute from the game config into this object.
void expand_scenario();
/// merges [carryover_sides_start] into [scenario] and saves the rest into [carryover_sides]
@ -69,6 +73,7 @@ public:
/// converts a normal savegame form the end of a scenaio to a start-of-scenario savefile for the next scenaio,
/// The saved_game must contain a [snapshot] made during the linger mode of the last scenaio.
void convert_to_start_save();
void set_random_seed();
/// @return the starting pos for replays. Usualy this is [replay_start] but it can also be a [scenario] if no [replay_start] is present
const config& get_replay_starting_pos();
/// @return the id of the currently played scenario or the id of the next scenario if this is a between-scenaios-save (also called start-of-scenario-save).
@ -88,13 +93,14 @@ public:
*/
config replay_data;
/** The carryover information for all sides that arent used in this scenario to be carried over to the next scenario */
config carryover_sides;
/** The carryover information for all sides as it was before the scenario started */
config carryover_sides_start;
private:
/** The carryover information for all sides that arent used in this scenario to be carried over to the next scenario */
config carryover_sides_;
/** The carryover information for all sides as it was before the scenario started */
config carryover_sides_start_;
/** snapshot made before the start event. To be used as a starting pos for replays */
config replay_start_;
/** some general information of the game that doesn't change during the game */

17
src/singleplayer.cpp
View File

@ -1,4 +1,5 @@
#include "singleplayer.hpp"
#include "config_assign.hpp"
#include "game_config_manager.hpp"
#include "gui/dialogs/campaign_selection.hpp"
#include "gui/dialogs/message.hpp"
@ -75,7 +76,6 @@ bool enter_create_mode(game_display& disp, const config& game_config,
create_eng.set_current_level(campaign_num);
std::string random_mode = use_deterministic_mode ? "deterministic" : "";
state.carryover_sides_start["random_mode"] = random_mode;
state.classification().random_mode = random_mode;
std::string selected_difficulty = create_eng.select_campaign_difficulty(jump_to_campaign.difficulty_);
@ -93,9 +93,18 @@ bool enter_create_mode(game_display& disp, const config& game_config,
create_eng.prepare_for_campaign(selected_difficulty);
if (jump_to_campaign.scenario_id_.empty())
state.carryover_sides_start["next_scenario"] = create_eng.current_level().data()["id"].str();
else {
state.carryover_sides_start["next_scenario"] = jump_to_campaign.scenario_id_;
{
state.set_carryover_sides_start(
config_of("random_mode", random_mode)
("next_scenario", create_eng.current_level().data()["id"].str())
);
}
else
{
state.set_carryover_sides_start(
config_of("random_mode", random_mode)
("next_scenario", jump_to_campaign.scenario_id_)
);
create_eng.current_level().set_data(
resources::config_manager->game_config().find_child(
lexical_cast<std::string> (game_classification::MULTIPLAYER),

5
src/tests/utils/play_scenario.cpp
View File

@ -18,6 +18,7 @@
#include "tests/utils/game_config_manager.hpp"
#include "tests/utils/fake_display.hpp"
#include "config_assign.hpp"
#include "game_display.hpp"
#include "saved_game.hpp"
#include "playcampaign.hpp"
@ -110,7 +111,9 @@ namespace test_utils {
saved_game& state = end->get_state();
state.classification().campaign_type = game_classification::TEST;
state.carryover_sides_start["next_scenario"] = id_;
state.set_carryover_sides_start(
config_of("next_scenario", id_)
);
play_game(get_fake_display(1024, 768), state, game_config_);
}