base_media_base.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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/>.
 */
 
#ifndef BASE_MEDIA_BASE_H
#define BASE_MEDIA_BASE_H
 
#include "fileio_func.h"
#include "gfx_type.h"
#include "textfile_type.h"
#include "textfile_gui.h"
#include "3rdparty/md5/md5.h"
#include <unordered_map>
 
/* Forward declare these; can't do 'struct X' in functions as older GCCs barf on that */
struct IniFile;
struct ContentInfo;
 
struct MD5File {
  enum ChecksumResult {
    CR_UNKNOWN,  
    CR_MATCH,    
    CR_MISMATCH, 
    CR_NO_FILE,  
  };
 
  std::string filename;        
  MD5Hash hash;                
  std::string missing_warning; 
  ChecksumResult check_result; 
 
  ChecksumResult CheckMD5(Subdirectory subdir, size_t max_size) const;
};
 
template <class T, size_t Tnum_files, bool Tsearch_in_tars>
struct BaseSet {
  typedef std::unordered_map<std::string, std::string> TranslatedStrings;
 
  static const size_t NUM_FILES = Tnum_files;
 
  static const bool SEARCH_IN_TARS = Tsearch_in_tars;
 
  static const char * const *file_names;
 
  std::string name;              
  std::string url;               
  TranslatedStrings description; 
  uint32_t shortname;              
  uint32_t version;                
  bool fallback;                 
 
  MD5File files[NUM_FILES];      
  uint found_files;              
  uint valid_files;              
 
  T *next;                       
 
  ~BaseSet()
  {
    delete this->next;
  }
 
  int GetNumMissing() const
  {
    return Tnum_files - this->found_files;
  }
 
  int GetNumInvalid() const
  {
    return Tnum_files - this->valid_files;
  }
 
  bool FillSetDetails(const IniFile &ini, const std::string &path, const std::string &full_filename, bool allow_empty_filename = true);
  void CopyCompatibleConfig([[maybe_unused]] const T &src) {}
 
  const std::string &GetDescription(const std::string &isocode) const
  {
    if (!isocode.empty()) {
      /* First the full ISO code */
      auto desc = this->description.find(isocode);
      if (desc != this->description.end()) return desc->second;
 
      /* Then the first two characters */
      desc = this->description.find(isocode.substr(0, 2));
      if (desc != this->description.end()) return desc->second;
    }
    /* Then fall back */
    return this->description.at(std::string{});
  }
 
  std::string GetListLabel() const
  {
    if (this->GetNumInvalid() == 0) return this->name;
 
    SetDParamStr(0, this->name);
    SetDParam(1, this->GetNumInvalid());
    return GetString(STR_BASESET_STATUS);
  }
 
  static MD5File::ChecksumResult CheckMD5(const MD5File *file, Subdirectory subdir)
  {
    return file->CheckMD5(subdir, SIZE_MAX);
  }
 
  std::optional<std::string> GetTextfile(TextfileType type) const
  {
    for (const auto &file : this->files) {
      auto textfile = ::GetTextfile(type, BASESET_DIR, file.filename);
      if (textfile.has_value()) {
        return textfile;
      }
    }
    return std::nullopt;
  }
};
 
template <class Tbase_set>
class BaseMedia : FileScanner {
protected:
  static Tbase_set *available_sets; 
  static Tbase_set *duplicate_sets; 
  static const Tbase_set *used_set; 
 
  bool AddFile(const std::string &filename, size_t basepath_length, const std::string &tar_filename) override;
 
  static const char *GetExtension();
public:
  static bool DetermineBestSet();
 
  static uint FindSets()
  {
    BaseMedia<Tbase_set> fs;
    /* Searching in tars is only done in the old "data" directories basesets. */
    uint num = fs.Scan(GetExtension(), Tbase_set::SEARCH_IN_TARS ? OLD_DATA_DIR : OLD_GM_DIR, Tbase_set::SEARCH_IN_TARS);
    return num + fs.Scan(GetExtension(), BASESET_DIR, Tbase_set::SEARCH_IN_TARS);
  }
 
  static Tbase_set *GetAvailableSets();
 
  static bool SetSet(const Tbase_set *set);
  static bool SetSetByName(const std::string &name);
  static bool SetSetByShortname(uint32_t shortname);
  static void GetSetsList(std::back_insert_iterator<std::string> &output_iterator);
  static int GetNumSets();
  static int GetIndexOfUsedSet();
  static const Tbase_set *GetSet(int index);
  static const Tbase_set *GetUsedSet();
 
  static bool HasSet(const ContentInfo *ci, bool md5sum);
};
 
template <class Tbase_set> /* static */ const Tbase_set *BaseMedia<Tbase_set>::used_set;
template <class Tbase_set> /* static */ Tbase_set *BaseMedia<Tbase_set>::available_sets;
template <class Tbase_set> /* static */ Tbase_set *BaseMedia<Tbase_set>::duplicate_sets;
 
template <class Tbase_set>
const char *TryGetBaseSetFile(const ContentInfo *ci, bool md5sum, const Tbase_set *s);
 
enum GraphicsFileType {
  GFT_BASE,     
  GFT_LOGOS,    
  GFT_ARCTIC,   
  GFT_TROPICAL, 
  GFT_TOYLAND,  
  GFT_EXTRA,    
  MAX_GFT,      
};
 
enum BlitterType {
  BLT_8BPP,       
  BLT_32BPP,      
};
 
struct GRFConfig;
 
struct GraphicsSet : BaseSet<GraphicsSet, MAX_GFT, true> {
private:
  mutable std::unique_ptr<GRFConfig> extra_cfg; 
public:
  PaletteType palette;       
  BlitterType blitter;       
 
  GraphicsSet();
  ~GraphicsSet();
 
  bool FillSetDetails(const IniFile &ini, const std::string &path, const std::string &full_filename);
  GRFConfig *GetExtraConfig() const { return this->extra_cfg.get(); }
  GRFConfig &GetOrCreateExtraConfig() const;
  bool IsConfigurable() const;
  void CopyCompatibleConfig(const GraphicsSet &src);
 
  static MD5File::ChecksumResult CheckMD5(const MD5File *file, Subdirectory subdir);
};
 
class BaseGraphics : public BaseMedia<GraphicsSet> {
public:
  struct Ini {
    std::string name;
    uint32_t shortname;                 
    uint32_t extra_version;             
    std::vector<uint32_t> extra_params; 
  };
  static inline Ini ini_data;
 
};
 
struct SoundsSet : BaseSet<SoundsSet, 1, true> {
};
 
class BaseSounds : public BaseMedia<SoundsSet> {
public:
  static inline std::string ini_set;
 
};
 
static const uint NUM_SONGS_CLASS     = 10;
static const uint NUM_SONG_CLASSES    = 3;
static const uint NUM_SONGS_AVAILABLE = 1 + NUM_SONG_CLASSES * NUM_SONGS_CLASS;
 
static const uint NUM_SONGS_PLAYLIST  = 32;
 
/* Functions to read DOS music CAT files, similar to but not quite the same as sound effect CAT files */
std::optional<std::string> GetMusicCatEntryName(const std::string &filename, size_t entrynum);
std::optional<std::vector<uint8_t>> GetMusicCatEntryData(const std::string &filename, size_t entrynum);
 
enum MusicTrackType {
  MTT_STANDARDMIDI, 
  MTT_MPSMIDI,      
};
 
struct MusicSongInfo {
  std::string songname;    
  uint8_t tracknr;            
  std::string filename;    
  MusicTrackType filetype; 
  int cat_index;           
  bool loop;               
  int override_start;      
  int override_end;        
};
 
struct MusicSet : BaseSet<MusicSet, NUM_SONGS_AVAILABLE, false> {
  MusicSongInfo songinfo[NUM_SONGS_AVAILABLE];
  uint8_t num_available;
 
  bool FillSetDetails(const IniFile &ini, const std::string &path, const std::string &full_filename);
};
 
class BaseMusic : public BaseMedia<MusicSet> {
public:
  static inline std::string ini_set;
 
};
 
#endif /* BASE_MEDIA_BASE_H */