NoteTypes.h

 
#ifndef NOTE_TYPES_H
#define NOTE_TYPES_H
 
#include "GameConstantsAndTypes.h"
#include "Core/Services/Locator.hpp"
 
class XNode;
 
struct TapNoteResult
{
    TapNoteResult() = default;
    TapNoteScore tns{ TNS_None };
 
    float fTapNoteOffset{ 1.F };
 
    bool bHidden{ false };
 
    // XML
    [[nodiscard]] auto CreateNode() const -> XNode*;
    void LoadFromNode(const XNode* pNode);
 
    // Lua
    void PushSelf(lua_State* L);
};
struct HoldNoteResult
{
    HoldNoteResult() = default;
    [[nodiscard]] auto GetLastHeldBeat() const -> float;
 
    HoldNoteScore hns{ HNS_None };
 
    float fLife{ 1.F };
 
    float fOverlappedTime{ 0 };
 
    int iLastHeldRow{ 0 };
 
    int iCheckpointsHit{ 0 };
    int iCheckpointsMissed{ 0 };
 
    bool bHeld{ false };
    bool bActive{ false };
 
    // XML
    [[nodiscard]] auto CreateNode() const -> XNode*;
    void LoadFromNode(const XNode* pNode);
 
    // Lua
    void PushSelf(lua_State* L);
};
 
enum TapNoteType
{
    TapNoteType_Empty,    
    TapNoteType_Tap,      
    TapNoteType_HoldHead, 
    TapNoteType_HoldTail, 
    TapNoteType_Mine, 
    TapNoteType_Lift, 
    TapNoteType_AutoKeysound, 
    TapNoteType_Fake, 
    NUM_TapNoteType,
    TapNoteType_Invalid
};
auto
TapNoteTypeToString(TapNoteType tnt) -> const std::string&;
auto
TapNoteTypeToLocalizedString(TapNoteType tnt) -> const std::string&;
LuaDeclareType(TapNoteType);
 
enum TapNoteSubType
{
    TapNoteSubType_Hold, 
    TapNoteSubType_Roll, 
    // TapNoteSubType_Mine,
    NUM_TapNoteSubType,
    TapNoteSubType_Invalid
};
auto
TapNoteSubTypeToString(TapNoteSubType tnst) -> const std::string&;
auto
TapNoteSubTypeToLocalizedString(TapNoteSubType tnst) -> const std::string&;
LuaDeclareType(TapNoteSubType);
 
enum TapNoteSource
{
    TapNoteSource_Original, 
    TapNoteSource_Addition, 
    NUM_TapNoteSource,
    TapNoteSource_Invalid
};
auto
TapNoteSourceToString(TapNoteSource tns) -> const std::string&;
auto
TapNoteSourceToLocalizedString(TapNoteSource tns) -> const std::string&;
LuaDeclareType(TapNoteSource);
 
struct TapNote
{
    TapNoteType type{ TapNoteType_Empty };
    TapNoteSubType subType{ TapNoteSubType_Invalid };
    TapNoteSource source{ TapNoteSource_Original };
    TapNoteResult result;
 
    // Index into Song's vector of keysound files if nonnegative:
    int iKeysoundIndex{ -1 };
 
    // also used for hold_head only:
    int iDuration{ 0 };
    HoldNoteResult HoldResult;
 
    // XML
    [[nodiscard]] auto CreateNode() const -> XNode*;
    void LoadFromNode(const XNode* pNode);
 
    // Lua
    void PushSelf(lua_State* L);
 
    // So I'm not repeatedly typing this out - Mina
    [[nodiscard]] auto IsNote() const -> bool
    {
        return type == TapNoteType_Tap || type == TapNoteType_HoldHead;
    }
 
    TapNote() = default;
    void Init()
    {
        type = TapNoteType_Empty;
        subType = TapNoteSubType_Invalid;
        source = TapNoteSource_Original;
        iDuration = 0;
    }
    TapNote(TapNoteType type_,
            TapNoteSubType subType_,
            TapNoteSource source_,
            int iKeysoundIndex_)
      : type(type_)
      , subType(subType_)
      , source(source_)
      , iKeysoundIndex(iKeysoundIndex_)
    {
        if (type_ > TapNoteType_Fake) {
            Locator::getLogger()->trace("Invalid tap note type {} (most likely) due to random "
                       "vanish issues. Assume it doesn't need judging.",
                       TapNoteTypeToString(type_).c_str());
            type = TapNoteType_Empty;
        }
    }
 
    auto operator==(const TapNote& other) const -> bool
    {
#define COMPARE(x)                                                             \
    if ((x) != other.x)                                                        \
    return false
        COMPARE(type);
        COMPARE(subType);
        COMPARE(source);
        COMPARE(iKeysoundIndex);
        COMPARE(iDuration);
#undef COMPARE
        return true;
    }
    auto operator!=(const TapNote& other) const -> bool
    {
        return !operator==(other);
    }
};
 
extern TapNote TAP_EMPTY;                  // '0'
extern TapNote TAP_ORIGINAL_TAP;           // '1'
extern TapNote TAP_ORIGINAL_HOLD_HEAD;     // '2'
extern TapNote TAP_ORIGINAL_ROLL_HEAD;     // '4'
extern TapNote TAP_ORIGINAL_MINE;          // 'M'
extern TapNote TAP_ORIGINAL_LIFT;          // 'L'
extern TapNote TAP_ORIGINAL_ATTACK;        // 'A'
extern TapNote TAP_ORIGINAL_AUTO_KEYSOUND; // 'K'
extern TapNote TAP_ORIGINAL_FAKE;          // 'F'
// extern TapNote TAP_ORIGINAL_MINE_HEAD;   // 'N' (tentative, we'll see when
// iDance gets ripped.)
extern TapNote TAP_ADDITION_TAP;
extern TapNote TAP_ADDITION_MINE;
 
const int MAX_NOTE_TRACKS = 16;
 
const int ROWS_PER_BEAT = 48;
 
const int MAX_NOTE_ROW = (1 << 30);
 
enum NoteType
{
    NOTE_TYPE_4TH,   
    NOTE_TYPE_8TH,   
    NOTE_TYPE_12TH,  
    NOTE_TYPE_16TH,  
    NOTE_TYPE_24TH,  
    NOTE_TYPE_32ND,  
    NOTE_TYPE_48TH,  
    NOTE_TYPE_64TH,  
    NOTE_TYPE_192ND, 
    NUM_NoteType,
    NoteType_Invalid
};
auto
NoteTypeToString(NoteType nt) -> const std::string&;
auto
NoteTypeToLocalizedString(NoteType nt) -> const std::string&;
LuaDeclareType(NoteType);
auto
NoteTypeToBeat(NoteType nt) -> float;
auto
NoteTypeToRow(NoteType nt) -> int;
auto
GetNoteType(int row) -> NoteType;
auto
BeatToNoteType(float fBeat) -> NoteType;
auto
IsNoteOfType(int row, NoteType t) -> bool;
 
/* This is more accurate: by computing the integer and fractional parts
separately, we
 * can avoid storing very large numbers in a float and possibly losing
precision.  It's
 * slower; use this once less stuff uses BeatToNoteRow.
 *
 *  This function rounds up.
inline int   BeatToNoteRow( float fBeatNum )
{
    float fraction = fBeatNum - truncf(fBeatNum);
    int integer = int(fBeatNum) * ROWS_PER_BEAT;
    return integer + lrintf(fraction * ROWS_PER_BEAT);
}
*/
 
inline auto
BeatToNoteRow(float fBeatNum) -> int
{
    return lround(fBeatNum * 48.F);
}
inline auto
NoteRowToBeat(int iRow) -> float
{
    return iRow / static_cast<float>(ROWS_PER_BEAT);
}
 
// These functions can be useful for function templates,
// where both rows and beats can be specified.
 
static inline auto
ToNoteRow(int row) -> int
{
    return row;
}
 
static inline auto
ToNoteRow(float beat) -> int
{
    return BeatToNoteRow(beat);
}
 
static inline auto
ToBeat(int row) -> float
{
    return NoteRowToBeat(row);
}
 
static inline auto
ToBeat(float beat) -> float
{
    return beat;
}
 
template<typename T>
auto
ScalePosition(T start, T length, T newLength, T position) -> T
{
    if (position < start)
        return position;
    if (position >= start + length)
        return position - length + newLength;
    return start + (position - start) * newLength / length;
}
 
#endif