MP Create: basic implementation of saved games as their own category (debug only)

src/game_initialization/create_engine.cpp

@@ -29,6 +29,7 @@
 #include "marked-up_text.hpp"
 #include "minimap.hpp"
 #include "saved_game.hpp"
+#include "save_index.hpp"
 #include "wml_separators.hpp"
 #include "wml_exception.hpp"
 
@@ -387,6 +388,28 @@ int campaign::max_players() const
 	return max_players_;
 }
 
+engine_saved_game::engine_saved_game(const config& data, const std::string name)
+	: scenario(data)
+	, name_(name)
+	, id_(data["id"])
+{
+}
+
+std::string engine_saved_game::name() const
+{
+	return name_;
+}
+
+std::string engine_saved_game::id() const
+{
+	return id_;
+}
+
+bool engine_saved_game::can_launch_game() const
+{
+	return !data()["corrupt"].to_bool(false);
+}
+
 create_engine::create_engine(CVideo& v, saved_game& state) :
 	current_level_type_(),
 	current_level_index_(0),
@@ -702,6 +725,11 @@ void create_engine::reset_level_filters()
 		random_maps_filtered_.push_back(i);
 	}
 
+	saved_games_filtered_.clear();
+	for (size_t i = 0; i<saved_games_.size(); i++) {
+		saved_games_filtered_.push_back(i);
+	}
+
 	level_name_filter_ = "";
 }
 
@@ -761,10 +789,13 @@ level& create_engine::current_level() const
 	case level::TYPE::CAMPAIGN: {
 		return *campaigns_[current_level_index_];
 	}
-	case level::TYPE::SP_CAMPAIGN:
-	default: {
+	case level::TYPE::SP_CAMPAIGN: {
 		return *sp_campaigns_[current_level_index_];
 	}
+	case level::TYPE::SAVED_GAME:
+	default: {
+		return *saved_games_[current_level_index_];
+	}
 	} // end switch
 }
 
@@ -808,6 +839,9 @@ void create_engine::set_current_level(const size_t index)
 			break;
 		case level::TYPE::USER_SCENARIO:
 			current_level_index_ = user_scenarios_filtered_.at(index);
+			break;
+		case level::TYPE::SAVED_GAME:
+			current_level_index_ = saved_games_filtered_.at(index);
 		}
 	}
 	catch (std::out_of_range&)
@@ -827,7 +861,8 @@ void create_engine::set_current_level(const size_t index)
 	}
 
 	if (current_level_type_ != level::TYPE::CAMPAIGN &&
-		current_level_type_ != level::TYPE::SP_CAMPAIGN) {
+		current_level_type_ != level::TYPE::SP_CAMPAIGN &&
+		current_level_type_ != level::TYPE::SAVED_GAME) {
 
 		dependency_manager_->try_scenario(current_level().id());
 	}
@@ -873,7 +908,7 @@ bool create_engine::generator_assigned() const
 
 bool create_engine::generator_has_settings() const
 {
-	return generator_->allow_user_config();
+	return generator_assigned() && generator_->allow_user_config();
 }
 
 void create_engine::generator_user_config(CVideo& v)
@@ -931,6 +966,14 @@ int create_engine::find_level_by_id(const std::string& id) const
 		i++;
 	}
 
+	i = 0;
+	for (saved_game_ptr saved_game : saved_games_) {
+		if (saved_game->id() == id) {
+			return i;
+		}
+		i++;
+	}
+
 	return -1;
 }
 
@@ -975,6 +1018,11 @@ level::TYPE create_engine::find_level_type_by_id(const std::string& id) const
 			return level::TYPE::CAMPAIGN;
 		}
 	}
+	for (saved_game_ptr saved_game : saved_games_) {
+		if (saved_game->id() == id) {
+			return level::TYPE::SAVED_GAME;
+		}
+	}
 	return level::TYPE::SP_CAMPAIGN;
 }
 
@@ -1139,6 +1187,17 @@ void create_engine::init_all_levels()
 
 	// Sort sp campaigns by rank.
 	std::stable_sort(sp_campaigns_.begin(),sp_campaigns_.end(),less_campaigns_rank);
+
+	// Saved games
+	for(const auto& save : savegame::get_saves_list()) {
+        // TODO: is this the right way to do this?
+		if(game_classification::CAMPAIGN_TYPE::string_to_enum(save.summary()["campaign_type"].str()) != game_classification::CAMPAIGN_TYPE::MULTIPLAYER) {
+			continue;
+		}
+
+		saved_game_ptr game(new engine_saved_game(save.summary(), save.name()));
+		saved_games_.push_back(game);
+	}
 }
 
 void create_engine::init_extras(const MP_EXTRA extra_type)
@@ -1222,6 +1281,15 @@ void create_engine::apply_level_filters()
 		}
 	}
 
+	saved_games_filtered_.clear();
+	for (size_t i = 0; i<saved_games_.size(); i++) {
+		//if (contains_ignore_case(saved_games_[i]->name(), level_name_filter_) &&
+		//	(player_count_filter_ == 1 ||
+		//	 saved_games_[i]->num_players() == player_count_filter_)) {
+			saved_games_filtered_.push_back(i);
+		//}
+	}
+
 }
 
 std::vector<create_engine::level_ptr>
@@ -1259,6 +1327,11 @@ std::vector<create_engine::level_ptr>
 			levels.push_back(level);
 		}
 		break;
+    case level::TYPE::SAVED_GAME:
+		for (level_ptr level : saved_games_) {
+			levels.push_back(level);
+		}
+		break;
 	} // end switch
 
 	return levels;
@@ -1298,6 +1371,12 @@ std::vector<create_engine::level_ptr> create_engine::get_levels_by_type(level::T
 			levels.push_back(sp_campaigns_[level]);
 		}
 		break;
+    case level::TYPE::SAVED_GAME:
+		for (size_t level : saved_games_filtered_) {
+			std::cerr << "pushing back saved game level\n";
+			levels.push_back(saved_games_[level]);
+		}
+		break;
 	} // end switch
 
 	return levels;
@@ -1318,6 +1397,8 @@ std::vector<size_t> create_engine::get_filtered_level_indices(level::TYPE type)
 		return campaigns_filtered_;
 	case level::TYPE::SP_CAMPAIGN:
 		return sp_campaigns_filtered_;
+    case level::TYPE::SAVED_GAME:
+		return saved_games_filtered_;
 	} // end switch
 
 	return std::vector<size_t>();

src/game_initialization/create_engine.hpp

@@ -18,6 +18,7 @@
 #include "utils/make_enum.hpp"
 #include "map/map.hpp"
 #include "mp_game_settings.hpp"
+#include "save_index.hpp"
 #include "sdl/utils.hpp"
 
 #include <string>
@@ -41,6 +42,7 @@ public:
 		(RANDOM_MAP,    "random_map")
 		(CAMPAIGN,      "campaign")
 		(SP_CAMPAIGN,   "sp_campaign")
+		(SAVED_GAME,    "saved_game")
 	)
 
 	virtual bool can_launch_game() const = 0;
@@ -175,6 +177,24 @@ private:
 	int max_players_;
 };
 
+class engine_saved_game : public scenario
+{
+public:
+	engine_saved_game(const config& data, const std::string name);
+
+	std::string name() const;
+	std::string id() const;
+
+	bool can_launch_game() const;
+
+private:
+	engine_saved_game(const engine_saved_game&);
+	void operator=(const engine_saved_game&);
+
+	std::string name_;
+	std::string id_;
+};
+
 class create_engine
 {
 public:
@@ -198,6 +218,7 @@ public:
 	typedef std::shared_ptr<user_map> user_map_ptr;
 	typedef std::shared_ptr<random_map> random_map_ptr;
 	typedef std::shared_ptr<campaign> campaign_ptr;
+	typedef std::shared_ptr<engine_saved_game> saved_game_ptr;
 
 	void init_generated_level_data();
 
@@ -293,6 +314,7 @@ private:
 	std::vector<campaign_ptr> campaigns_;
 	std::vector<campaign_ptr> sp_campaigns_;
 	std::vector<random_map_ptr> random_maps_;
+	std::vector<saved_game_ptr> saved_games_;
 
 	std::vector<size_t> scenarios_filtered_;
 	std::vector<size_t> user_maps_filtered_;
@@ -300,6 +322,7 @@ private:
 	std::vector<size_t> campaigns_filtered_;
 	std::vector<size_t> sp_campaigns_filtered_;
 	std::vector<size_t> random_maps_filtered_;
+	std::vector<size_t> saved_games_filtered_;
 
 	std::vector<std::string> user_map_names_;
 	std::vector<std::string> user_scenario_names_;

src/game_initialization/multiplayer_create.cpp

@@ -446,6 +446,8 @@ void create::process_event_impl(const process_event_data & data)
 
 			break;
 		}
+		case ng::level::TYPE::SAVED_GAME:
+			break;
 		} // end switch
 
 		map_size_label_.set_text(map_size.str());

src/gui/dialogs/multiplayer/mp_create_game.cpp

@@ -21,6 +21,7 @@
 #include "gettext.hpp"
 #include "gui/auxiliary/field.hpp"
 #include "gui/dialogs/helper.hpp"
+#include "gui/dialogs/message.hpp"
 #include "gui/dialogs/transient_message.hpp"
 #include "gui/widgets/integer_selector.hpp"
 #include "gui/widgets/button.hpp"
@@ -89,10 +90,11 @@ tmp_create_game::tmp_create_game(const config& cfg, ng::create_engine& create_en
 		{ng::level::TYPE::CAMPAIGN, _("Campaigns")},
 		{ng::level::TYPE::USER_MAP, _("User Maps")},
 		{ng::level::TYPE::USER_SCENARIO, _("User Scenarios")},
-		{ng::level::TYPE::RANDOM_MAP, _("Random Maps")}
+		{ng::level::TYPE::RANDOM_MAP, _("Random Maps")},
 	};
 
 	if(game_config::debug) {
+		level_types_.push_back({ng::level::TYPE::SAVED_GAME, _("Saved Games")});
 		level_types_.push_back({ng::level::TYPE::SP_CAMPAIGN, _("SP Campaigns")});
 	}
 
@@ -611,7 +613,8 @@ void tmp_create_game::update_details(twindow& window)
 		case ng::level::TYPE::SCENARIO:
 		case ng::level::TYPE::USER_MAP:
 		case ng::level::TYPE::USER_SCENARIO:
-		case ng::level::TYPE::RANDOM_MAP: {
+		case ng::level::TYPE::RANDOM_MAP:
+		case ng::level::TYPE::SAVED_GAME: {
 			ng::scenario* current_scenario = dynamic_cast<ng::scenario*>(&create_engine_.current_level());
 
 			assert(current_scenario);
@@ -717,6 +720,24 @@ void tmp_create_game::post_show(twindow& window)
 	find_widget<tstacked_widget>(&window, "pager", false).select_layer(-1);
 
 	if(get_retval() == twindow::OK) {
+		// Saved games have a different loading process... at least, right now
+		if(create_engine_.current_level_type() == ng::level::TYPE::SAVED_GAME) {
+			std::string error_log;
+			savegame::read_save_file(create_engine_.current_level().name(), create_engine_.current_level().data(), &error_log);
+			//copy_era(create_engine_.current_level().data()); TODO
+
+			if(!error_log.empty()) {
+				gui2::show_error_message(window.video(), _("The file you have tried to load is corrupt: '") + error_log);
+				return;
+			}
+
+			create_engine_.get_state().set_data(create_engine_.current_level().data());
+
+			create_engine_.prepare_for_saved_game();
+
+			return;
+		}
+	
 		preferences::set_modifications(create_engine_.active_mods());
 		preferences::set_level_type(create_engine_.current_level_type().v);
 		preferences::set_level(create_engine_.current_level().id());