src/fios.cpp

   1 /*
   2  * This file is part of OpenTTD.
   3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   6  */
   7
   8 /**
   9  * @file fios.cpp
  10  * This file contains functions for building file lists for the save/load dialogs.
  11  */
  12
  13 #include "stdafx.h"
  14 #include "3rdparty/md5/md5.h"
  15 #include "fileio_func.h"
  16 #include "fios.h"
  17 #include "network/network_content.h"
  18 #include "screenshot.h"
  19 #include "string_func.h"
  20 #include "strings_func.h"
  21 #include "tar_type.h"
  22 #include <sys/stat.h>
  23 #include <charconv>
  24 #include <filesystem>
  25
  26 #include "table/strings.h"
  27
  28 #include "safeguards.h"
  29
  30 /* Variables to display file lists */
  31 static std::string *_fios_path = nullptr;
  32 SortingBits _savegame_sort_order = SORT_BY_DATE | SORT_DESCENDING;
  33
  34 /* OS-specific functions are taken from their respective files (win32/unix .c) */
  35 extern bool FiosIsRoot(const std::string &path);
  36 extern bool FiosIsHiddenFile(const std::filesystem::path &path);
  37 extern void FiosGetDrives(FileList &file_list);
  38
  39 /* get the name of an oldstyle savegame */
  40 extern std::string GetOldSaveGameName(const std::string &file);
  41
  42 /**
  43  * Compare two FiosItem's. Used with sort when sorting the file list.
  44  * @param other The FiosItem to compare to.
  45  * @return for ascending order: returns true if da < db. Vice versa for descending order.
  46  */
  47 bool FiosItem::operator< (const FiosItem &other) const
  48 {
  49         int r = false;
  50
  51         if ((_savegame_sort_order & SORT_BY_NAME) == 0 && (*this).mtime != other.mtime) {
  52                 r = ClampTo<int32_t>(this->mtime - other.mtime);
  53         } else {
  54                 r = StrNaturalCompare((*this).title, other.title);
  55         }
  56         if (r == 0) return false;
  57         return (_savegame_sort_order & SORT_DESCENDING) ? r > 0 : r < 0;
  58 }
  59
  60 /**
  61  * Construct a file list with the given kind of files, for the stated purpose.
  62  * @param abstract_filetype Kind of files to collect.
  63  * @param fop Purpose of the collection, either #SLO_LOAD or #SLO_SAVE.
  64  * @param show_dirs Whether to show directories.
  65  */
  66 void FileList::BuildFileList(AbstractFileType abstract_filetype, SaveLoadOperation fop, bool show_dirs)
  67 {
  68         this->clear();
  69
  70         assert(fop == SLO_LOAD || fop == SLO_SAVE);
  71         switch (abstract_filetype) {
  72                 case FT_NONE:
  73                         break;
  74
  75                 case FT_SAVEGAME:
  76                         FiosGetSavegameList(fop, show_dirs, *this);
  77                         break;
  78
  79                 case FT_SCENARIO:
  80                         FiosGetScenarioList(fop, show_dirs, *this);
  81                         break;
  82
  83                 case FT_HEIGHTMAP:
  84                         FiosGetHeightmapList(fop, show_dirs, *this);
  85                         break;
  86
  87                 default:
  88                         NOT_REACHED();
  89         }
  90 }
  91
  92 /**
  93  * Find file information of a file by its name from the file list.
  94  * @param file The filename to return information about. Can be the actual name
  95  *             or a numbered entry into the filename list.
  96  * @return The information on the file, or \c nullptr if the file is not available.
  97  */
  98 const FiosItem *FileList::FindItem(const std::string_view file)
  99 {
 100         for (const auto &it : *this) {
 101                 const FiosItem *item = &it;
 102                 if (file == item->name) return item;
 103                 if (file == item->title) return item;
 104         }
 105
 106         /* If no name matches, try to parse it as number */
 107         char *endptr;
 108         int i = std::strtol(file.data(), &endptr, 10);
 109         if (file.data() == endptr || *endptr != '\0') i = -1;
 110
 111         if (IsInsideMM(i, 0, this->size())) return &this->at(i);
 112
 113         /* As a last effort assume it is an OpenTTD savegame and
 114          * that the ".sav" part was not given. */
 115         std::string long_file(file);
 116         long_file += ".sav";
 117         for (const auto &it : *this) {
 118                 const FiosItem *item = &it;
 119                 if (long_file == item->name) return item;
 120                 if (long_file == item->title) return item;
 121         }
 122
 123         return nullptr;
 124 }
 125
 126 /**
 127  * Get the current path/working directory.
 128  */
 129 std::string FiosGetCurrentPath()
 130 {
 131         return *_fios_path;
 132 }
 133
 134 /**
 135  * Browse to a new path based on the passed \a item, starting at #_fios_path.
 136  * @param *item Item telling us what to do.
 137  * @return \c true when the path got changed.
 138  */
 139 bool FiosBrowseTo(const FiosItem *item)
 140 {
 141         switch (item->type) {
 142                 case FIOS_TYPE_DRIVE:
 143 #if defined(_WIN32)
 144                         assert(_fios_path != nullptr);
 145                         *_fios_path = std::string{ item->title, 0, 1 } + ":" PATHSEP;
 146 #endif
 147                         break;
 148
 149                 case FIOS_TYPE_INVALID:
 150                         break;
 151
 152                 case FIOS_TYPE_PARENT: {
 153                         assert(_fios_path != nullptr);
 154                         auto s = _fios_path->find_last_of(PATHSEPCHAR);
 155                         if (s != std::string::npos && s != 0) {
 156                                 _fios_path->erase(s); // Remove last path separator character, so we can go up one level.
 157                         }
 158
 159                         s = _fios_path->find_last_of(PATHSEPCHAR);
 160                         if (s != std::string::npos) {
 161                                 _fios_path->erase(s + 1); // go up a directory
 162                         }
 163                         break;
 164                 }
 165
 166                 case FIOS_TYPE_DIR:
 167                         assert(_fios_path != nullptr);
 168                         *_fios_path += item->name;
 169                         *_fios_path += PATHSEP;
 170                         break;
 171
 172                 case FIOS_TYPE_DIRECT:
 173                         assert(_fios_path != nullptr);
 174                         *_fios_path = item->name;
 175                         break;
 176
 177                 case FIOS_TYPE_FILE:
 178                 case FIOS_TYPE_OLDFILE:
 179                 case FIOS_TYPE_SCENARIO:
 180                 case FIOS_TYPE_OLD_SCENARIO:
 181                 case FIOS_TYPE_PNG:
 182                 case FIOS_TYPE_BMP:
 183                         return false;
 184         }
 185
 186         return true;
 187 }
 188
 189 /**
 190  * Construct a filename from its components in destination buffer \a buf.
 191  * @param path Directory path, may be \c nullptr.
 192  * @param name Filename.
 193  * @param ext Filename extension (use \c "" for no extension).
 194  * @return The completed filename.
 195  */
 196 static std::string FiosMakeFilename(const std::string *path, const char *name, const char *ext)
 197 {
 198         std::string buf;
 199
 200         if (path != nullptr) {
 201                 buf = *path;
 202                 /* Remove trailing path separator, if present */
 203                 if (!buf.empty() && buf.back() == PATHSEPCHAR) buf.pop_back();
 204         }
 205
 206         /* Don't append the extension if it is already there */
 207         const char *period = strrchr(name, '.');
 208         if (period != nullptr && StrEqualsIgnoreCase(period, ext)) ext = "";
 209
 210         return buf + PATHSEP + name + ext;
 211 }
 212
 213 /**
 214  * Make a save game or scenario filename from a name.
 215  * @param name Name of the file.
 216  * @return The completed filename.
 217  */
 218 std::string FiosMakeSavegameName(const char *name)
 219 {
 220         const char *extension = (_game_mode == GM_EDITOR) ? ".scn" : ".sav";
 221
 222         return FiosMakeFilename(_fios_path, name, extension);
 223 }
 224
 225 /**
 226  * Construct a filename for a height map.
 227  * @param name Filename.
 228  * @return The completed filename.
 229  */
 230 std::string FiosMakeHeightmapName(const char *name)
 231 {
 232         std::string ext(".");
 233         ext += GetCurrentScreenshotExtension();
 234
 235         return FiosMakeFilename(_fios_path, name, ext.c_str());
 236 }
 237
 238 /**
 239  * Delete a file.
 240  * @param name Filename to delete.
 241  * @return Whether the file deletion was successful.
 242  */
 243 bool FiosDelete(const char *name)
 244 {
 245         return FioRemove(FiosMakeSavegameName(name));
 246 }
 247
 248 typedef std::tuple<FiosType, std::string> FiosGetTypeAndNameProc(SaveLoadOperation fop, const std::string &filename, const std::string_view ext);
 249
 250 /**
 251  * Scanner to scan for a particular type of FIOS file.
 252  */
 253 class FiosFileScanner : public FileScanner {
 254         SaveLoadOperation fop;   ///< The kind of file we are looking for.
 255         FiosGetTypeAndNameProc *callback_proc; ///< Callback to check whether the file may be added
 256         FileList &file_list;     ///< Destination of the found files.
 257 public:
 258         /**
 259          * Create the scanner
 260          * @param fop Purpose of collecting the list.
 261          * @param callback_proc The function that is called where you need to do the filtering.
 262          * @param file_list Destination of the found files.
 263          */
 264         FiosFileScanner(SaveLoadOperation fop, FiosGetTypeAndNameProc *callback_proc, FileList &file_list) :
 265                         fop(fop), callback_proc(callback_proc), file_list(file_list)
 266         {}
 267
 268         bool AddFile(const std::string &filename, size_t basepath_length, const std::string &tar_filename) override;
 269 };
 270
 271 /**
 272  * Try to add a fios item set with the given filename.
 273  * @param filename        the full path to the file to read
 274  * @return true if the file is added.
 275  */
 276 bool FiosFileScanner::AddFile(const std::string &filename, size_t, const std::string &)
 277 {
 278         auto sep = filename.rfind('.');
 279         if (sep == std::string::npos) return false;
 280         std::string ext = filename.substr(sep);
 281
 282         auto [type, title] = this->callback_proc(this->fop, filename, ext);
 283         if (type == FIOS_TYPE_INVALID) return false;
 284
 285         for (const auto &fios : file_list) {
 286                 if (filename == fios.name) return false;
 287         }
 288
 289         FiosItem *fios = &file_list.emplace_back();
 290
 291         std::error_code error_code;
 292         auto write_time = std::filesystem::last_write_time(OTTD2FS(filename), error_code);
 293         if (error_code) {
 294                 fios->mtime = 0;
 295         } else {
 296                 fios->mtime = std::chrono::duration_cast<std::chrono::milliseconds>(write_time.time_since_epoch()).count();
 297         }
 298
 299         fios->type = type;
 300         fios->name = filename;
 301
 302         /* If the file doesn't have a title, use its filename */
 303         if (title.empty()) {
 304                 auto ps = filename.rfind(PATHSEPCHAR);
 305                 fios->title = StrMakeValid(filename.substr((ps == std::string::npos ? 0 : ps + 1)));
 306         } else {
 307                 fios->title = StrMakeValid(title);
 308         };
 309
 310         return true;
 311 }
 312
 313
 314 /**
 315  * Fill the list of the files in a directory, according to some arbitrary rule.
 316  * @param fop Purpose of collecting the list.
 317  * @param show_dirs Whether to list directories.
 318  * @param callback_proc The function that is called where you need to do the filtering.
 319  * @param subdir The directory from where to start (global) searching.
 320  * @param file_list Destination of the found files.
 321  */
 322 static void FiosGetFileList(SaveLoadOperation fop, bool show_dirs, FiosGetTypeAndNameProc *callback_proc, Subdirectory subdir, FileList &file_list)
 323 {
 324         size_t sort_start;
 325
 326         file_list.clear();
 327
 328         assert(_fios_path != nullptr);
 329
 330         if (show_dirs) {
 331                 /* A parent directory link exists if we are not in the root directory */
 332                 if (!FiosIsRoot(*_fios_path)) {
 333                         FiosItem &fios = file_list.emplace_back();
 334                         fios.type = FIOS_TYPE_PARENT;
 335                         fios.mtime = 0;
 336                         fios.name = "..";
 337                         SetDParamStr(0, "..");
 338                         fios.title = GetString(STR_SAVELOAD_PARENT_DIRECTORY);
 339                 }
 340
 341                 /* Show subdirectories */
 342                 std::error_code error_code;
 343                 for (const auto &dir_entry : std::filesystem::directory_iterator(OTTD2FS(*_fios_path), error_code)) {
 344                         if (!dir_entry.is_directory()) continue;
 345                         if (FiosIsHiddenFile(dir_entry) && dir_entry.path().filename() != PERSONAL_DIR) continue;
 346
 347                         FiosItem &fios = file_list.emplace_back();
 348                         fios.type = FIOS_TYPE_DIR;
 349                         fios.mtime = 0;
 350                         fios.name = FS2OTTD(dir_entry.path().filename());
 351                         SetDParamStr(0, fios.name + PATHSEP);
 352                         fios.title = GetString(STR_SAVELOAD_DIRECTORY);
 353                 }
 354
 355                 /* Sort the subdirs always by name, ascending, remember user-sorting order */
 356                 SortingBits order = _savegame_sort_order;
 357                 _savegame_sort_order = SORT_BY_NAME | SORT_ASCENDING;
 358                 std::sort(file_list.begin(), file_list.end());
 359                 _savegame_sort_order = order;
 360         }
 361
 362         /* This is where to start sorting for the filenames */
 363         sort_start = file_list.size();
 364
 365         /* Show files */
 366         FiosFileScanner scanner(fop, callback_proc, file_list);
 367         if (subdir == NO_DIRECTORY) {
 368                 scanner.Scan({}, *_fios_path, false);
 369         } else {
 370                 scanner.Scan({}, subdir, true, true);
 371         }
 372
 373         std::sort(file_list.begin() + sort_start, file_list.end());
 374
 375         /* Show drives */
 376         FiosGetDrives(file_list);
 377 }
 378
 379 /**
 380  * Get the title of a file, which (if exists) is stored in a file named
 381  * the same as the data file but with '.title' added to it.
 382  * @param file filename to get the title for
 383  * @param subdir the sub directory to search in
 384  * @return The file title.
 385  */
 386 static std::string GetFileTitle(const std::string &file, Subdirectory subdir)
 387 {
 388         FILE *f = FioFOpenFile(file + ".title", "r", subdir);
 389         if (f == nullptr) return {};
 390
 391         char title[80];
 392         size_t read = fread(title, 1, lengthof(title), f);
 393         FioFCloseFile(f);
 394
 395         assert(read <= lengthof(title));
 396         return StrMakeValid({title, read});
 397 }
 398
 399 /**
 400  * Callback for FiosGetFileList. It tells if a file is a savegame or not.
 401  * @param fop Purpose of collecting the list.
 402  * @param file Name of the file to check.
 403  * @param ext A pointer to the extension identifier inside file
 404  * @return a FIOS_TYPE_* type of the found file, FIOS_TYPE_INVALID if not a savegame, and the title of the file (if any).
 405  * @see FiosGetFileList
 406  * @see FiosGetSavegameList
 407  */
 408 std::tuple<FiosType, std::string> FiosGetSavegameListCallback(SaveLoadOperation fop, const std::string &file, const std::string_view ext)
 409 {
 410         /* Show savegame files
 411          * .SAV OpenTTD saved game
 412          * .SS1 Transport Tycoon Deluxe preset game
 413          * .SV1 Transport Tycoon Deluxe (Patch) saved game
 414          * .SV2 Transport Tycoon Deluxe (Patch) saved 2-player game */
 415
 416         if (StrEqualsIgnoreCase(ext, ".sav")) {
 417                 return { FIOS_TYPE_FILE, GetFileTitle(file, SAVE_DIR) };
 418         }
 419
 420         if (fop == SLO_LOAD) {
 421                 if (StrEqualsIgnoreCase(ext, ".ss1") || StrEqualsIgnoreCase(ext, ".sv1") ||
 422                                 StrEqualsIgnoreCase(ext, ".sv2")) {
 423                         return { FIOS_TYPE_OLDFILE, GetOldSaveGameName(file) };
 424                 }
 425         }
 426
 427         return { FIOS_TYPE_INVALID, {} };
 428 }
 429
 430 /**
 431  * Get a list of savegames.
 432  * @param fop Purpose of collecting the list.
 433  * @param show_dirs Whether to show directories.
 434  * @param file_list Destination of the found files.
 435  * @see FiosGetFileList
 436  */
 437 void FiosGetSavegameList(SaveLoadOperation fop, bool show_dirs, FileList &file_list)
 438 {
 439         static std::optional<std::string> fios_save_path;
 440
 441         if (!fios_save_path) fios_save_path = FioFindDirectory(SAVE_DIR);
 442
 443         _fios_path = &(*fios_save_path);
 444
 445         FiosGetFileList(fop, show_dirs, &FiosGetSavegameListCallback, NO_DIRECTORY, file_list);
 446 }
 447
 448 /**
 449  * Callback for FiosGetFileList. It tells if a file is a scenario or not.
 450  * @param fop Purpose of collecting the list.
 451  * @param file Name of the file to check.
 452  * @param ext A pointer to the extension identifier inside file
 453  * @return a FIOS_TYPE_* type of the found file, FIOS_TYPE_INVALID if not a scenario and the title of the file (if any).
 454  * @see FiosGetFileList
 455  * @see FiosGetScenarioList
 456  */
 457 std::tuple<FiosType, std::string> FiosGetScenarioListCallback(SaveLoadOperation fop, const std::string &file, const std::string_view ext)
 458 {
 459         /* Show scenario files
 460          * .SCN OpenTTD style scenario file
 461          * .SV0 Transport Tycoon Deluxe (Patch) scenario
 462          * .SS0 Transport Tycoon Deluxe preset scenario */
 463         if (StrEqualsIgnoreCase(ext, ".scn")) {
 464                 return { FIOS_TYPE_SCENARIO, GetFileTitle(file, SCENARIO_DIR) };
 465
 466         }
 467
 468         if (fop == SLO_LOAD) {
 469                 if (StrEqualsIgnoreCase(ext, ".sv0") || StrEqualsIgnoreCase(ext, ".ss0")) {
 470                         return { FIOS_TYPE_OLD_SCENARIO, GetOldSaveGameName(file) };
 471                 }
 472         }
 473
 474         return { FIOS_TYPE_INVALID, {} };
 475 }
 476
 477 /**
 478  * Get a list of scenarios.
 479  * @param fop Purpose of collecting the list.
 480  * @param show_dirs Whether to show directories.
 481  * @param file_list Destination of the found files.
 482  * @see FiosGetFileList
 483  */
 484 void FiosGetScenarioList(SaveLoadOperation fop, bool show_dirs, FileList &file_list)
 485 {
 486         static std::optional<std::string> fios_scn_path;
 487
 488         /* Copy the default path on first run or on 'New Game' */
 489         if (!fios_scn_path) fios_scn_path = FioFindDirectory(SCENARIO_DIR);
 490
 491         _fios_path = &(*fios_scn_path);
 492
 493         std::string base_path = FioFindDirectory(SCENARIO_DIR);
 494         Subdirectory subdir = (fop == SLO_LOAD && base_path == *_fios_path) ? SCENARIO_DIR : NO_DIRECTORY;
 495         FiosGetFileList(fop, show_dirs, &FiosGetScenarioListCallback, subdir, file_list);
 496 }
 497
 498 std::tuple<FiosType, std::string> FiosGetHeightmapListCallback(SaveLoadOperation, const std::string &file, const std::string_view ext)
 499 {
 500         /* Show heightmap files
 501          * .PNG PNG Based heightmap files
 502          * .BMP BMP Based heightmap files
 503          */
 504
 505         FiosType type = FIOS_TYPE_INVALID;
 506
 507 #ifdef WITH_PNG
 508         if (StrEqualsIgnoreCase(ext, ".png")) type = FIOS_TYPE_PNG;
 509 #endif /* WITH_PNG */
 510
 511         if (StrEqualsIgnoreCase(ext, ".bmp")) type = FIOS_TYPE_BMP;
 512
 513         if (type == FIOS_TYPE_INVALID) return { FIOS_TYPE_INVALID, {} };
 514
 515         TarFileList::iterator it = _tar_filelist[SCENARIO_DIR].find(file);
 516         if (it != _tar_filelist[SCENARIO_DIR].end()) {
 517                 /* If the file is in a tar and that tar is not in a heightmap
 518                  * directory we are for sure not supposed to see it.
 519                  * Examples of this are pngs part of documentation within
 520                  * collections of NewGRFs or 32 bpp graphics replacement PNGs.
 521                  */
 522                 bool match = false;
 523                 for (Searchpath sp : _valid_searchpaths) {
 524                         std::string buf = FioGetDirectory(sp, HEIGHTMAP_DIR);
 525
 526                         if (buf.compare(0, buf.size(), it->second.tar_filename, 0, buf.size()) == 0) {
 527                                 match = true;
 528                                 break;
 529                         }
 530                 }
 531
 532                 if (!match) return { FIOS_TYPE_INVALID, {} };
 533         }
 534
 535         return { type, GetFileTitle(file, HEIGHTMAP_DIR) };
 536 }
 537
 538 /**
 539  * Get a list of heightmaps.
 540  * @param fop Purpose of collecting the list.
 541  * @param show_dirs Whether to show directories.
 542  * @param file_list Destination of the found files.
 543  */
 544 void FiosGetHeightmapList(SaveLoadOperation fop, bool show_dirs, FileList &file_list)
 545 {
 546         static std::optional<std::string> fios_hmap_path;
 547
 548         if (!fios_hmap_path) fios_hmap_path = FioFindDirectory(HEIGHTMAP_DIR);
 549
 550         _fios_path = &(*fios_hmap_path);
 551
 552         std::string base_path = FioFindDirectory(HEIGHTMAP_DIR);
 553         Subdirectory subdir = base_path == *_fios_path ? HEIGHTMAP_DIR : NO_DIRECTORY;
 554         FiosGetFileList(fop, show_dirs, &FiosGetHeightmapListCallback, subdir, file_list);
 555 }
 556
 557 /**
 558  * Get the directory for screenshots.
 559  * @return path to screenshots
 560  */
 561 const char *FiosGetScreenshotDir()
 562 {
 563         static std::optional<std::string> fios_screenshot_path;
 564
 565         if (!fios_screenshot_path) fios_screenshot_path = FioFindDirectory(SCREENSHOT_DIR);
 566
 567         return fios_screenshot_path->c_str();
 568 }
 569
 570 /** Basic data to distinguish a scenario. Used in the server list window */
 571 struct ScenarioIdentifier {
 572         uint32_t scenid;           ///< ID for the scenario (generated by content).
 573         MD5Hash md5sum;          ///< MD5 checksum of file.
 574         std::string filename;    ///< filename of the file.
 575
 576         bool operator == (const ScenarioIdentifier &other) const
 577         {
 578                 return this->scenid == other.scenid && this->md5sum == other.md5sum;
 579         }
 580
 581         bool operator != (const ScenarioIdentifier &other) const
 582         {
 583                 return !(*this == other);
 584         }
 585 };
 586
 587 /**
 588  * Scanner to find the unique IDs of scenarios
 589  */
 590 class ScenarioScanner : protected FileScanner, public std::vector<ScenarioIdentifier> {
 591         bool scanned; ///< Whether we've already scanned
 592 public:
 593         /** Initialise */
 594         ScenarioScanner() : scanned(false) {}
 595
 596         /**
 597          * Scan, but only if it's needed.
 598          * @param rescan whether to force scanning even when it's not necessary
 599          */
 600         void Scan(bool rescan)
 601         {
 602                 if (this->scanned && !rescan) return;
 603
 604                 this->FileScanner::Scan(".id", SCENARIO_DIR, true, true);
 605                 this->scanned = true;
 606         }
 607
 608         bool AddFile(const std::string &filename, size_t, const std::string &) override
 609         {
 610                 FILE *f = FioFOpenFile(filename, "r", SCENARIO_DIR);
 611                 if (f == nullptr) return false;
 612
 613                 ScenarioIdentifier id;
 614                 int fret = fscanf(f, "%u", &id.scenid);
 615                 FioFCloseFile(f);
 616                 if (fret != 1) return false;
 617                 id.filename = filename;
 618
 619                 Md5 checksum;
 620                 uint8_t buffer[1024];
 621                 size_t len, size;
 622
 623                 /* open the scenario file, but first get the name.
 624                  * This is safe as we check on extension which
 625                  * must always exist. */
 626                 f = FioFOpenFile(filename.substr(0, filename.rfind('.')), "rb", SCENARIO_DIR, &size);
 627                 if (f == nullptr) return false;
 628
 629                 /* calculate md5sum */
 630                 while ((len = fread(buffer, 1, (size > sizeof(buffer)) ? sizeof(buffer) : size, f)) != 0 && size != 0) {
 631                         size -= len;
 632                         checksum.Append(buffer, len);
 633                 }
 634                 checksum.Finish(id.md5sum);
 635
 636                 FioFCloseFile(f);
 637
 638                 include(*this, id);
 639                 return true;
 640         }
 641 };
 642
 643 /** Scanner for scenarios */
 644 static ScenarioScanner _scanner;
 645
 646 /**
 647  * Find a given scenario based on its unique ID.
 648  * @param ci The content info to compare it to.
 649  * @param md5sum Whether to look at the md5sum or the id.
 650  * @return The filename of the file, else \c nullptr.
 651  */
 652 const char *FindScenario(const ContentInfo *ci, bool md5sum)
 653 {
 654         _scanner.Scan(false);
 655
 656         for (ScenarioIdentifier &id : _scanner) {
 657                 if (md5sum ? (id.md5sum == ci->md5sum)
 658                            : (id.scenid == ci->unique_id)) {
 659                         return id.filename.c_str();
 660                 }
 661         }
 662
 663         return nullptr;
 664 }
 665
 666 /**
 667  * Check whether we've got a given scenario based on its unique ID.
 668  * @param ci The content info to compare it to.
 669  * @param md5sum Whether to look at the md5sum or the id.
 670  * @return True iff we've got the scenario.
 671  */
 672 bool HasScenario(const ContentInfo *ci, bool md5sum)
 673 {
 674         return (FindScenario(ci, md5sum) != nullptr);
 675 }
 676
 677 /**
 678  * Force a (re)scan of the scenarios.
 679  */
 680 void ScanScenarios()
 681 {
 682         _scanner.Scan(true);
 683 }
 684
 685 /**
 686  * Constructs FiosNumberedSaveName. Initial number is the most recent save, or -1 if not found.
 687  * @param prefix The prefix to use to generate a filename.
 688  */
 689 FiosNumberedSaveName::FiosNumberedSaveName(const std::string &prefix) : prefix(prefix), number(-1)
 690 {
 691         static std::optional<std::string> _autosave_path;
 692         if (!_autosave_path) _autosave_path = FioFindDirectory(AUTOSAVE_DIR);
 693
 694         static std::string _prefix; ///< Static as the lambda needs access to it.
 695
 696         /* Callback for FiosFileScanner. */
 697         static FiosGetTypeAndNameProc *proc = [](SaveLoadOperation, const std::string &file, const std::string_view ext) {
 698                 if (StrEqualsIgnoreCase(ext, ".sav") && file.starts_with(_prefix)) return std::tuple(FIOS_TYPE_FILE, std::string{});
 699                 return std::tuple(FIOS_TYPE_INVALID, std::string{});
 700         };
 701
 702         /* Prefix to check in the callback. */
 703         _prefix = *_autosave_path + this->prefix;
 704
 705         /* Get the save list. */
 706         FileList list;
 707         FiosFileScanner scanner(SLO_SAVE, proc, list);
 708         scanner.Scan(".sav", *_autosave_path, false);
 709
 710         /* Find the number for the most recent save, if any. */
 711         if (list.begin() != list.end()) {
 712                 SortingBits order = _savegame_sort_order;
 713                 _savegame_sort_order = SORT_BY_DATE | SORT_DESCENDING;
 714                 std::sort(list.begin(), list.end());
 715                 _savegame_sort_order = order;
 716
 717                 std::string_view name = list.begin()->title;
 718                 std::from_chars(name.data() + this->prefix.size(), name.data() + name.size(), this->number);
 719         }
 720 }
 721
 722 /**
 723  * Generate a savegame name and number according to _settings_client.gui.max_num_autosaves.
 724  * @return A filename in format "<prefix><number>.sav".
 725  */
 726 std::string FiosNumberedSaveName::Filename()
 727 {
 728         if (++this->number >= _settings_client.gui.max_num_autosaves) this->number = 0;
 729         return fmt::format("{}{}.sav", this->prefix, this->number);
 730 }
 731
 732 /**
 733  * Generate an extension for a savegame name.
 734  * @return An extension in format "-<prefix>.sav".
 735  */
 736 std::string FiosNumberedSaveName::Extension()
 737 {
 738         return fmt::format("-{}.sav", this->prefix);
 739 }