void ValidateFileList(bool force_reload = false)

	{

		if (force_reload || !this->file_list_valid) {

			this->file_list_valid = true;

		}

	}

		char *filename = str_fmt("%s.sav", argv[1]);

		IConsolePrint(CC_DEFAULT, "Saving map...");

			IConsolePrint(CC_ERROR, "Saving map failed");

		} else {

			IConsolePrintF(CC_DEFAULT, "Map successfully saved to %s", filename);

		seprintf(filename, filename_last, "%scrash.sav", _personal_dir);

		/* Don't do a threaded saveload. */

	} catch (...) {

		return false;

	}

};

/** Operation performed on the file. */

};

/**

/**

 * Construct a file list with the given kind of files, for the stated purpose.

 * @param abstract_filetype Kind of files to collect.

 */

{

	this->Clear();

	switch (abstract_filetype) {

		case FT_NONE:

			break;

	return unlink(filename) == 0;

}

/**

 * Scanner to scan for a particular type of FIOS file.

 */

class FiosFileScanner : public FileScanner {

	fios_getlist_callback_proc *callback_proc; ///< Callback to check whether the file may be added

	FileList &file_list;     ///< Destination of the found files.

public:

	 * @param callback_proc The function that is called where you need to do the filtering.

	 * @param file_list Destination of the found files.

	 */

			fop(fop), callback_proc(callback_proc), file_list(file_list)

	{}

 * @param subdir The directory from where to start (global) searching.

 * @param file_list Destination of the found files.

 */

{

	struct stat sb;

	struct dirent *dirent;

 * @see FiosGetFileList

 * @see FiosGetSavegameList

 */

{

	/* Show savegame files

	 * .SAV OpenTTD saved game

		return FIOS_TYPE_FILE;

	}

		if (strcasecmp(ext, ".ss1") == 0 || strcasecmp(ext, ".sv1") == 0 ||

				strcasecmp(ext, ".sv2") == 0) {

			if (title != NULL) GetOldSaveGameName(file, title, last);

 * @param file_list Destination of the found files.

 * @see FiosGetFileList

 */

{

	static char *fios_save_path = NULL;

	static char *fios_save_path_last = NULL;

 * @see FiosGetFileList

 * @see FiosGetScenarioList

 */

{

	/* Show scenario files

	 * .SCN OpenTTD style scenario file

		return FIOS_TYPE_SCENARIO;

	}

		if (strcasecmp(ext, ".sv0") == 0 || strcasecmp(ext, ".ss0") == 0 ) {

			GetOldSaveGameName(file, title, last);

			return FIOS_TYPE_OLD_SCENARIO;

 * @param file_list Destination of the found files.

 * @see FiosGetFileList

 */

{

	static char *fios_scn_path = NULL;

	static char *fios_scn_path_last = NULL;

	char base_path[MAX_PATH];

	FioGetDirectory(base_path, lastof(base_path), SCENARIO_DIR);

	FiosGetFileList(fop, &FiosGetScenarioListCallback, subdir, file_list);

}

{

	/* Show heightmap files

	 * .PNG PNG Based heightmap files

 * @param fop Purpose of collecting the list.

 * @param file_list Destination of the found files.

 */

{

	static char *fios_hmap_path = NULL;

	static char *fios_hmap_path_last = NULL;

		this->files.Compact();

	}

	const FiosItem *FindItem(const char *file);

	SmallVector<FiosItem, 32> files; ///< The list of files.

/* Variables to display file lists */

extern SortingBits _savegame_sort_order;

const char *FiosBrowseTo(const FiosItem *item);

void FiosMakeHeightmapName(char *buf, const char *name, const char *last);

void FiosMakeSavegameName(char *buf, const char *name, const char *last);

int CDECL CompareFiosItems(const FiosItem *a, const FiosItem *b);

private:

	QueryString filename_editbox; ///< Filename editbox.

	AbstractFileType abstract_filetype; /// Type of file to select.

	FileList fios_items;          ///< Save game list.

	FiosItem o_dir;

	const FiosItem *selected;     ///< Selected game in #fios_items, or \c NULL.

		this->filename_editbox.text.UpdateSize();

	}

			: Window(desc), filename_editbox(64), abstract_filetype(abstract_filetype), fop(fop)

	{

		/* For saving, construct an initial file name. */

			switch (this->abstract_filetype) {

				case FT_SAVEGAME:

					this->GenerateFileName();

		this->filename_editbox.ok_button = WID_SL_SAVE_GAME;

		this->CreateNestedTree(true);

			this->GetWidget<NWidgetStacked>(WID_SL_CONTENT_DOWNLOAD_SEL)->SetDisplayedPlane(SZSP_HORIZONTAL);

		}

		StringID caption_string;

		switch (this->abstract_filetype) {

			case FT_SAVEGAME:

				break;

			case FT_SCENARIO:

				break;

			case FT_HEIGHTMAP:

				break;

			default:

		}

		/* Focus the edit box by default in the save windows */

	}

	virtual ~SaveLoadWindow()

					}

					/* Hide the NewGRF stuff when saving. We also hide the button. */

						y += WD_PAR_VSEP_NORMAL;

						if (y > y_max) break;

							if (GetDetailedFileType(file->type) == DFT_GAME_FILE) {

								/* Other detailed file types cannot be checked before. */

							}

							this->InvalidateData(1);

						}

							/* Copy clicked name to editbox */

							this->filename_editbox.text.Assign(file->title);

							this->SetWidgetDirty(WID_SL_SAVE_OSK_TITLE);

						}

					} else if (!_load_check_data.HasErrors()) {

						this->selected = file;

							if (this->abstract_filetype == FT_SAVEGAME || this->abstract_filetype == FT_SCENARIO) {

								this->OnClick(pt, WID_SL_LOAD_BUTTON, 1);

							} else {

					ShowErrorMessage(STR_NETWORK_ERROR_NOTAVAILABLE, INVALID_STRING_ID, WL_ERROR);

				} else {

#if defined(ENABLE_NETWORK)

					switch (this->abstract_filetype) {

						default: NOT_REACHED();

						case FT_SCENARIO:  ShowNetworkContentListWindow(NULL, CONTENT_TYPE_SCENARIO);  break;

	virtual void OnTimeout()

	{

		/* Widgets WID_SL_DELETE_SELECTION and WID_SL_SAVE_GAME only exist when saving to a file. */

		if (this->IsWidgetLowered(WID_SL_DELETE_SELECTION)) { // Delete button clicked

			if (!FiosDelete(this->filename_editbox.text.buf)) {

				/* Selection changes */

				if (!gui_scope) break;

				switch (this->abstract_filetype) {

					case FT_HEIGHTMAP:

 * @param abstract_filetype Kind of file to handle.

 * @param fop File operation to perform (load or save).

 */

{

	DeleteWindowById(WC_SAVELOAD, 0);

	WindowDesc *sld;

		sld = &_save_dialog_desc;

	} else {

		/* Dialogue for loading a file. */

		if (_debug_desync_level > 0) {

			char name[MAX_PATH];

			seprintf(name, lastof(name), "dmp_cmds_%08x_%08x.sav", _settings_game.game_creation.generation_seed, _date);

		}

	} catch (...) {

		BasePersistentStorageArray::SwitchMode(PSM_LEAVE_GAMELOOP, true);

				}

				break;

			case WID_SGI_EDIT_SCENARIO:  StartScenarioEditor(); break;

			case WID_SGI_PLAY_NETWORK:

 *   DEF_CLIENT_RECEIVE_COMMAND has parameter: Packet *p

 ************/

NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_FULL(Packet *p)

{

	/* The map is done downloading, load it */

	ClearErrorMessages();

	/* Long savegame loads shouldn't affect the lag calculation! */

	this->last_packet = _realtime_tick;

			case WID_NSS_LOAD_GAME:

				_is_network_server = true;

				break;

			case WID_NSS_PLAY_SCENARIO:

				_is_network_server = true;

				break;

			case WID_NSS_PLAY_HEIGHTMAP:

				_is_network_server = true;

				break;

		}

	}

	SetupColoursAndInitialWindow();

	/* Load the default opening screen savegame */

		GenerateWorld(GWM_EMPTY, 64, 64); // if failed loading, make empty world.

		WaitTillGeneratedWorld();

		SetLocalCompany(COMPANY_SPECTATOR);

				_file_to_saveload.SetName(mgo.opt);

				bool is_scenario = _switch_mode == SM_EDITOR || _switch_mode == SM_LOAD_SCENARIO;

				_switch_mode = is_scenario ? SM_LOAD_SCENARIO : SM_LOAD_GAME;

				/* if the file doesn't exist or it is not a valid savegame, let the saveload code show an error */

				const char *t = strrchr(_file_to_saveload.name, '.');

				if (t != NULL) {

					if (ft != FIOS_TYPE_INVALID) _file_to_saveload.SetMode(ft);

				}

			char title[80];

			title[0] = '\0';

			_load_check_data.Clear();

			if (res != SL_OK || _load_check_data.HasErrors()) {

				fprintf(stderr, "Failed to open savegame\n");

				if (_load_check_data.HasErrors()) {

 * @param subdir default directory to look for filename, set to 0 if not needed

 * @param lf Load filter to use, if NULL: use filename + subdir.

 */

{

	assert(dft == DFT_GAME_FILE || (lf == NULL && dft == DFT_OLD_GAME_FILE));

	GameMode ogm = _game_mode;

		case SM_SAVE_GAME: // Save game.

			/* Make network saved games on pause compatible to singleplayer */

				SetDParamStr(0, GetSaveLoadErrorString());

				ShowErrorMessage(STR_JUST_RAW_STRING, INVALID_STRING_ID, WL_ERROR);

			} else {

			/* Save the desync savegame if needed. */

			char name[MAX_PATH];

			seprintf(name, lastof(name), "dmp_cmds_%08x_%08x.sav", _settings_game.game_creation.generation_seed, _date);

		}

		CheckCaches();

	}

	DEBUG(sl, 2, "Autosaving to '%s'", buf);

		ShowErrorMessage(STR_ERROR_AUTOSAVE_FAILED, INVALID_STRING_ID, WL_ERROR);

	}

}

 * @param threaded True when threaded saving is allowed

 * @return Return the result of the action. #SL_OK, #SL_ERROR, or #SL_REINIT ("unload" the game)

 */

{

	/* An instance of saving is already active, so don't go saving again */

		/* if not an autosave, but a user action, show error message */

		if (!_do_autosave) ShowErrorMessage(STR_ERROR_SAVE_STILL_IN_PROGRESS, INVALID_STRING_ID, WL_ERROR);

		return SL_OK;

	try {

		/* Load a TTDLX or TTDPatch game */

			InitializeGame(256, 256, true, true); // set a mapsize of 256x256 for TTDPatch games or it might get confused

			/* TTD/TTO savegames have no NewGRFs, TTDP savegame have them

		assert(dft == DFT_GAME_FILE);

		switch (fop) {

				_sl.action = SLA_LOAD_CHECK;

				break;

				_sl.action = SLA_LOAD;

				break;

				_sl.action = SLA_SAVE;

				break;

			default: NOT_REACHED();

		}

		/* Make it a little easier to load savegames from the console */

		if (fh == NULL) {

		}

			DEBUG(desync, 1, "save: %08x; %02x; %s", _date, _date_fract, filename);

			if (_network_server || !_settings_client.gui.threaded_saves) threaded = false;

		}

		/* LOAD game */

		DEBUG(desync, 1, "load: %s", filename);

	} catch (...) {

		/* This code may be executed both for old and new save games. */

		ClearSaveLoadState();

		/* Skip the "colour" character */

		/* A saver/loader exception!! reinitialize all variables to prevent crash! */

	}

}

/** Do a save when exiting the game (_settings_client.gui.autosave_on_exit) */

void DoExitSave()

{

}

/**

 */

void FileToSaveLoad::SetMode(FiosType ft)

{

}

/**

 * @param aft Abstract file type.

 * @param dft Detailed file type.

 */

{

	if (aft == FT_INVALID || aft == FT_NONE) {

		this->detail_ftype = DFT_INVALID;

		this->abstract_ftype = FT_INVALID;

		return;

/** Deals with the type of the savegame, independent of extension */

struct FileToSaveLoad {

	DetailedFileType detail_ftype;   ///< Concrete file type (PNG, BMP, old save, etc).

	AbstractFileType abstract_ftype; ///< Abstract type of file (scenario, heightmap, etc).

	char name[MAX_PATH];             ///< Name of the file.

	char title[255];                 ///< Internal name of the game.

	void SetMode(FiosType ft);

	void SetName(const char *name);

	void SetTitle(const char *title);

};

void GenerateDefaultSaveName(char *buf, const char *last);

void SetSaveLoadError(uint16 str);

const char *GetSaveLoadErrorString();

void WaitTillSaved();

void ProcessAsyncSaveFinish();

void DoExitSave();

{

	if (_game_mode == GM_EDITOR) {

		switch (index) {

			case SLEME_EXIT_TOINTRO:   AskExitToGameMenu();                    break;

			case SLEME_EXIT_GAME:      HandleExitGameRequest();                break;

		}

	} else {

		switch (index) {

			case SLNME_EXIT_TOINTRO:   AskExitToGameMenu();               break;

			case SLNME_EXIT_GAME:      HandleExitGameRequest();           break;

		}

			case MTHK_FASTFORWARD: ToolbarFastForwardClick(this); break;

			case MTHK_SETTINGS: ShowGameOptions(); break;

			case MTHK_SAVEGAME: MenuClickSaveLoad(); break;

			case MTHK_SMALLMAP: ShowSmallMap(); break;

			case MTHK_TOWNDIRECTORY: ShowTownDirectory(); break;

			case MTHK_SUBSIDIES: ShowSubsidiesList(); break;

/* Whether a fork has been done. */

bool _dedicated_forks;

static FVideoDriver_Dedicated iFVideoDriver_Dedicated;