NotesLoaderSSC.h

 
#ifndef NotesLoaderSSC_H
#define NotesLoaderSSC_H
 
#include "NotesLoaderSM.h"
 
class MsdFile;
class Song;
class Steps;
class TimingData;
struct SSCLoader;
enum SSCLoadingStates
{
    GETTING_SONG_INFO,   
    GETTING_STEP_INFO,   
    NUM_SSCLoadingStates 
};
 
// LoadNoteDataFromSimfile uses LoadNoteDataTagIDs because its parts operate
// on state variables internal to the function.
namespace SSC {
enum LoadNoteDataTagIDs
{
    LNDID_version,
    LNDID_stepstype,
    LNDID_chartname,
    LNDID_description,
    LNDID_difficulty,
    LNDID_meter,
    LNDID_credit,
    LNDID_notes,
    LNDID_notes2,
    LNDID_notedata
};
 
// LoadNoteDataFromSimfile uses LoadNoteDataTagIDs because its parts operate
// on state variables internal to the function.struct StepsTagInfo
struct StepsTagInfo
{
    SSCLoader* loader;
    Song* song;
    Steps* steps;
    TimingData* timing;
    const MsdFile::value_t* params;
    const std::string& path;
    bool has_own_timing;
    bool ssc_format;
    bool from_cache;
    bool for_load_edit;
    StepsTagInfo(SSCLoader* l, Song* s, const std::string& p, bool fc)
      : loader(l)
      , song(s)
      , steps(nullptr)
      , timing(nullptr)
      , path(p)
      , has_own_timing(false)
      , ssc_format(false)
      , from_cache(fc)
      , for_load_edit(false)
    {
        params = nullptr;
    }
};
struct SongTagInfo
{
    SSCLoader* loader;
    Song* song;
    const MsdFile::value_t* params{ nullptr };
    const std::string& path;
    bool from_cache;
    SongTagInfo(SSCLoader* l, Song* s, const std::string& p, bool fc)
      : loader(l)
      , song(s)
      , path(p)
      , from_cache(fc)
    {
    }
};
std::vector<float>
msdsplit(const std::string& s);
}
const float VERSION_RADAR_FAKE = 0.53f;
const float VERSION_WARP_SEGMENT = 0.56f;
const float VERSION_SPLIT_TIMING = 0.7f;
const float VERSION_OFFSET_BEFORE_ATTACK = 0.72f;
const float VERSION_CHART_NAME_TAG = 0.74f;
const float VERSION_CACHE_SWITCH_TAG = 0.77f;
const float VERSION_RADAR_NOTECOUNT = 0.83f;
 
struct SSCLoader : public SMLoader
{
    SSCLoader()
      : SMLoader(".ssc")
    {
    }
 
    bool LoadFromSimfile(const std::string& sPath,
                         Song& out,
                         bool bFromCache = false) override;
 
    bool LoadNoteDataFromSimfile(const std::string& cachePath,
                                 Steps& out) override;
 
    static void ProcessBPMs(TimingData&,
                            const std::string& sParam,
                            const std::string& songName);
    static void ProcessStops(TimingData&,
                             const std::string& sParam,
                             const std::string& songName);
    static void ProcessWarps(TimingData&,
                             const std::string& sParam,
                             const float,
                             const std::string& songName);
    static void ProcessLabels(TimingData& out,
                              const std::string& sParam,
                              const std::string& songName);
    static void ProcessCombos(TimingData&,
                              const std::string& line,
                              const std::string& songName,
                              const int = -1);
    void ProcessCombos(TimingData&,
                       const std::string& line,
                       const int = -1) override;
    static void ProcessScrolls(TimingData&,
                               const std::string sParam,
                               const std::string& songName);
};
 
#endif