void manager::delete_game(const std::string& name)
{
std::string modified_name = name;
replace_space2underbar(modified_name);
remove((get_saves_dir() + "/" + name).c_str());
remove((get_saves_dir() + "/" + modified_name).c_str());
}
std::vector<save_info> manager::get_saves_list(const std::string *dir, const std::string* filter)
{
// Don't use a reference, it seems to break on arklinux with GCC-4.3.
std::string saves_dir = (dir) ? *dir : get_saves_dir();
#ifdef _WIN32
conv_ansi_utf8(saves_dir, false);
#endif
std::vector<std::string> saves;
get_files_in_dir(saves_dir,&saves);
std::vector<save_info> res;
for(std::vector<std::string>::iterator i = saves.begin(); i != saves.end(); ++i) {
if(filter && std::search(i->begin(), i->end(), filter->begin(), filter->end()) == i->end()) {
continue;
}
const time_t modified = file_create_time(saves_dir + "/" + *i);
// replace_underbar2space(*i);
#ifdef _WIN32
res.push_back(save_info(conv_ansi_utf8_2(*i, true), modified));
#else
res.push_back(save_info(*i, modified));
#endif
}
std::sort(res.begin(),res.end(),save_info_less_time());
return res;
}
WESNOTH_PARAMETERIZED_TEST_CASE( test_dialog_get_save_name_enter_pressed, SDLKey, dialog_get_save_name_enter_pressed, keyid )
{
// fill in events to be used in test
test_utils::event_node_ptr press_return_before = source.press_key(0, keyid);
test_utils::event_node_ptr release_return_before = source.release_key(3, keyid);
test_utils::event_node_ptr press_return_after = source.press_key(5, keyid);
test_utils::event_node_ptr release_return_after = source.release_key(7, keyid);
// Protection agains for ever loop
source.press_key(10, keyid);
source.release_key(13, keyid);
std::string fname("test_save");
write_file(get_saves_dir() + "/" + fname +".gz", "böö");
// Start test (set ticks start time)
// Activated enter press
events::pump();
BOOST_CHECK_MESSAGE(press_return_before->is_fired(), "Enter wasn't activated");
BOOST_CHECK_MESSAGE(!release_return_before->is_fired(), "Enter was released before test");
/*
After moving the savegame code to savegame.cpp, there need to be a lot more parameters to pass to the
savegame class, that are not available here. Just to give an impression, this could be the code to call
the dialog:
game_savegame save(gamestate, level, gui, teams, units, gamestatus, map, game_preferences::compress_saves());
save.save_game_interactive(gui, "Save game", gui::OK_CANCEL, false, false);
This code however does not compile anymore:
BOOST_CHECK_EQUAL(dialogs::get_save_name_oos(test_utils::get_fake_display(1024, 768),
"Save game?", "file", &fname,gui::OK_CANCEL, "Save game"), 0);
Not sure how to fix it best.
BOOST_CHECK_MESSAGE(release_return_before->is_fired(), "get_save_name returned before releasing first enter.");
BOOST_CHECK_MESSAGE(press_return_after->is_fired(), "get_save_name returned before 2nd enter event was sent");
BOOST_CHECK_MESSAGE(!release_return_after->is_fired(), "get_save_name returned after 2nd release event was sent");
*/
remove((get_saves_dir() + "/" + fname + ".gz").c_str());
}
// Throws game::save_game_failed
scoped_ostream savegame::open_save_game(const std::string &label)
{
std::string name = label;
replace_space2underbar(name);
try {
return scoped_ostream(ostream_file(get_saves_dir() + "/" + name));
} catch(io_exception& e) {
throw game::save_game_failed(e.what());
}
}
bool manager::save_game_exists(const std::string& name, const bool compress_saves)
{
std::string fname = name;
replace_space2underbar(fname);
if(compress_saves) {
fname += ".gz";
}
return file_exists(get_saves_dir() + "/" + fname);
}
bool manager::save_game_exists(const std::string& name)
{
// std::string fname = name;
// replace_space2underbar(fname);
std::string fullname = get_saves_dir() + "/" + name + ".sav";
#ifdef _WIN32
conv_ansi_utf8(fullname, false);
#endif
return file_exists(fullname);
}
void manager::read_save_file(const std::string& name, config& cfg, std::string* error_log)
{
std::string modified_name = name;
replace_space2underbar(modified_name);
// Try reading the file both with and without underscores, if needed append .gz as well
scoped_istream file_stream = istream_file(get_saves_dir() + "/" + modified_name);
if (file_stream->fail()) {
file_stream = istream_file(get_saves_dir() + "/" + name);
}
if(file_stream->fail() && !is_gzip_file(modified_name)) {
file_stream = istream_file(get_saves_dir() + "/" + modified_name + ".gz");
if (file_stream->fail()) {
file_stream = istream_file(get_saves_dir() + "/" + name + ".gz");
}
modified_name += ".gz";
}
cfg.clear();
try{
/*
* Test the modified name, since it might use a .gz
* file even when not requested.
*/
if(is_gzip_file(modified_name)) {
read_gz(cfg, *file_stream);
} else {
read(cfg, *file_stream);
}
} catch (config::error &err)
{
LOG_SAVE << err.message;
if (error_log) *error_log += err.message;
throw game::load_game_failed();
}
if(cfg.empty()) {
LOG_SAVE << "Could not parse file data into config\n";
throw game::load_game_failed();
}
}
void manager::delete_game(const std::string& name)
{
// std::string modified_name = name;
// replace_space2underbar(modified_name);
std::string fullname = get_saves_dir() + "/" + name;
#ifdef _WIN32
conv_ansi_utf8(fullname, false);
#endif
remove(fullname.c_str());
// remove((get_saves_dir() + "/" + modified_name).c_str());
}
void savegame::finish_save_game(const config_writer &out)
{
std::string name = gamestate_.classification().label;
replace_space2underbar(name);
std::string fname(get_saves_dir() + "/" + name);
try {
if(!out.good()) {
throw game::save_game_failed(_("Could not write to file"));
}
config& summary = save_index::save_summary(gamestate_.classification().label);
extract_summary_data_from_save(summary);
const int mod_time = static_cast<int>(file_create_time(fname));
summary["mod_time"] = str_cast(mod_time);
save_index::write_save_index();
} catch(io_exception& e) {
throw game::save_game_failed(e.what());
}
}
void tgame_load::xmit_button_callback(twindow& window)
{
tlistbox& list = *lists_[current_page_];
const size_t index = size_t(list.get_selected_row());
if (current_page_ == LOCAL_PAGE) {
if (index < games_.size()) {
// See if we should ask the user for deletion confirmation
std::string message = _("You can upload one only, it will delete existed, continue?");
const int res = gui2::show_message(disp_.video(), _("Confirm"), message, gui2::tmessage::yes_no_buttons);
if (res == gui2::twindow::CANCEL) {
return;
}
config cfg_summary;
std::string dummy;
try {
savegame::manager::load_summary(games_[index].name, cfg_summary, &dummy);
} catch(game::load_game_failed&) {
message = _("This file is corrupted, can not upload!");
gui2::show_message(disp_.video(), _("Confirm"), message);
return;
}
http::upload_save(disp_, heros_, get_saves_dir() + "/" + games_[index].name);
}
} else if (current_page_ == NETWORK_PAGE) {
if (index < www_saves_.size()) {
std::string fname = http::download_save(disp_, heros_, www_saves_[index].sid);
if (!fname.empty()) {
sheet_.find(LOCAL_PAGE)->second->set_value(true);
sheet_toggled(sheet_.find(LOCAL_PAGE)->second);
}
}
}
}
void tgame_load::xmit_button_callback(twindow& window)
{
const size_t index = size_t(savegame_list_->get_selected_row());
if (current_page_ == LOCAL_PAGE) {
if (index < games_.size()) {
// See if we should ask the user for deletion confirmation
std::string message = dsgettext("wesnoth", "You can upload one only, it will delete existed, continue?");
const int res = gui2::show_message(disp_.video(), dsgettext("wesnoth", "Confirm"), message, gui2::tmessage::yes_no_buttons);
if (res == gui2::twindow::CANCEL) {
return;
}
http::upload_save(disp_, get_saves_dir() + "/" + games_[index].name);
}
} else if (current_page_ == NETWORK_PAGE) {
if (index < www_saves_.size()) {
std::string fname = http::download_save(disp_, www_saves_[index].sid);
if (!fname.empty()) {
sheet_.find(LOCAL_PAGE)->second->set_value(true);
sheet_toggled(sheet_.find(LOCAL_PAGE)->second);
}
}
}
}
void savegame::write_game_to_disk(const std::string& filename)
{
filename_ = filename;
filename_ += ".sav";
std::stringstream ss;
{
config_writer out(ss, false);
write_game(out);
}
// start scenario data(write it to stream only first, others write stream to file direct)
if (!gamestate_.start_scenario_ss.str().length()) {
::write(gamestate_.start_scenario_ss, gamestate_.starting_pos);
}
if (!gamestate_.start_hero_data_) {
gamestate_.start_hero_data_ = (uint8_t*)malloc(heros_start_.file_size());
heros_start_.map_to_mem(gamestate_.start_hero_data_);
}
config cfg_summary;
std::stringstream summary_ss;
extract_summary_data_from_save(cfg_summary);
::write(summary_ss, cfg_summary);
// if enable compress, ss.str() is compressed format data.
posix_file_t fp;
uint32_t summary_size, scenario_size, side_size, start_scenario_size, start_hero_size, replay_size, hero_size, member_data_size, bytertd;
int size;
// replace_space2underbar(filename_);
std::string fullfilename = get_saves_dir() + "/" + filename_;
#ifdef _WIN32
// utf8 ---> utf16
int wlen = MultiByteToWideChar(CP_UTF8, 0, fullfilename.c_str(), -1, NULL, 0);
WCHAR *wc = new WCHAR[wlen];
MultiByteToWideChar(CP_UTF8, 0, fullfilename.c_str(), -1, wc, wlen);
fp = CreateFileW(wc, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
CREATE_ALWAYS, 0, NULL);
// posix_fopen(wc, GENERIC_WRITE, CREATE_ALWAYS, fp);
delete [] wc;
#else
posix_fopen(fullfilename.c_str(), GENERIC_WRITE, CREATE_ALWAYS, fp);
#endif
if (fp == INVALID_FILE) {
throw game::save_game_failed(_("Could not write to file"));
}
// length of summary data
summary_size = summary_ss.str().length();
// length of scenario data
scenario_size = ss.str().length();
// length of side data
side_size = ((unit_segment2*)game_config::savegame_cache)->size_;
// length of start scenario data
start_scenario_size = gamestate_.start_scenario_ss.str().length();
// length of start hero data
start_hero_size = heros_start_.file_size();
// length of replay data
if (gamestate_.replay_data.pool_pos_vsize()) {
replay_size = 16 + gamestate_.replay_data.pool_data_gzip_size() + gamestate_.replay_data.pool_pos_vsize() * sizeof(unsigned int);
} else {
replay_size = 0;
}
// length of runtime hero data
hero_size = heros_.file_size();
// length of runtime-member data
member_data_size = runtime_groups::size();
// [write] length of summary data
posix_fwrite(fp, &summary_size, sizeof(summary_size), bytertd);
// [write] length of scenario data
posix_fwrite(fp, &scenario_size, sizeof(scenario_size), bytertd);
// [write] length of side data
posix_fwrite(fp, &side_size, sizeof(side_size), bytertd);
// [write] length of start scenario data
posix_fwrite(fp, &start_scenario_size, sizeof(start_scenario_size), bytertd);
// [write] length of start hero data
posix_fwrite(fp, &start_hero_size, sizeof(start_hero_size), bytertd);
// [write] length of replay data
posix_fwrite(fp, &replay_size, sizeof(replay_size), bytertd);
// [write] length of runtime hero data
posix_fwrite(fp, &hero_size, sizeof(hero_size), bytertd);
// [write] length of member data
posix_fwrite(fp, &member_data_size, sizeof(member_data_size), bytertd);
// summary data
posix_fwrite(fp, summary_ss.str().c_str(), summary_ss.str().length(), bytertd);
// scenario data
posix_fwrite(fp, ss.str().c_str(), ss.str().length(), bytertd);
// side data
if (side_size) {
posix_fwrite(fp, game_config::savegame_cache, side_size, bytertd);
}
// start scenario data
posix_fwrite(fp, gamestate_.start_scenario_ss.str().c_str(), gamestate_.start_scenario_ss.str().length(), bytertd);
// start hero data
posix_fwrite(fp, gamestate_.start_hero_data_, start_hero_size, bytertd);
// replay data
if (replay_size) {
size = gamestate_.replay_data.pool_data_size();
posix_fwrite(fp, &size, sizeof(size), bytertd);
size = gamestate_.replay_data.pool_data_gzip_size();
posix_fwrite(fp, &size, sizeof(size), bytertd);
size = gamestate_.replay_data.pool_pos_size();
posix_fwrite(fp, &size, sizeof(size), bytertd);
size = gamestate_.replay_data.pool_pos_vsize();
posix_fwrite(fp, &size, sizeof(size), bytertd);
// pool data
posix_fwrite(fp, gamestate_.replay_data.pool_data(), gamestate_.replay_data.pool_data_gzip_size(), bytertd);
// pool pos
posix_fwrite(fp, gamestate_.replay_data.pool_pos(), gamestate_.replay_data.pool_pos_vsize() * sizeof(unsigned int), bytertd);
}
// hero data
heros_.map_to_file_fp(fp);
// member data
runtime_groups::to_fp(fp);
posix_fclose(fp);
}
