Chris Danford
837 lines
20 KiB
C++
837 lines
20 KiB
C++
#include "stdafx.h"
|
|
/*
|
|
-----------------------------------------------------------------------------
|
|
Class: NoteData
|
|
|
|
Desc: See header.
|
|
|
|
Copyright (c) 2001-2002 by the person(s) listed below. All rights reserved.
|
|
Chris Danford
|
|
-----------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "NoteData.h"
|
|
#include "RageUtil.h"
|
|
#include "GameConstantsAndTypes.h"
|
|
#include "PrefsManager.h"
|
|
#include "ArrowEffects.h"
|
|
#include "PrefsManager.h"
|
|
#include "GameConstantsAndTypes.h"
|
|
#include "RageException.h"
|
|
|
|
|
|
|
|
NoteData::NoteData()
|
|
{
|
|
Init();
|
|
}
|
|
|
|
void NoteData::Init()
|
|
{
|
|
memset( m_TapNotes, '0', MAX_NOTE_TRACKS*MAX_TAP_NOTE_ROWS*sizeof(m_TapNotes[0][0]) );
|
|
m_iNumTracks = 0;
|
|
m_iNumHoldNotes = 0;
|
|
}
|
|
|
|
NoteData::~NoteData()
|
|
{
|
|
}
|
|
|
|
|
|
void NoteData::LoadFromSMNoteDataString( CString sSMNoteData )
|
|
{
|
|
int iNumTracks = m_iNumTracks;
|
|
NoteData::Init();
|
|
m_iNumTracks = iNumTracks;
|
|
|
|
// strip comments out of sSMNoteData
|
|
while( sSMNoteData.Find("//") != -1 )
|
|
{
|
|
int iIndexCommentStart = sSMNoteData.Find("//");
|
|
int iIndexCommentEnd = sSMNoteData.Find("\n", iIndexCommentStart);
|
|
if( iIndexCommentEnd == -1 ) // comment doesn't have an end?
|
|
sSMNoteData.Delete( iIndexCommentStart, 2 );
|
|
else
|
|
sSMNoteData.Delete( iIndexCommentStart, iIndexCommentEnd-iIndexCommentStart );
|
|
}
|
|
|
|
CStringArray asMeasures;
|
|
split( sSMNoteData, ",", asMeasures, true ); // ignore empty is important
|
|
for( int m=0; m<asMeasures.GetSize(); m++ ) // foreach measure
|
|
{
|
|
CString &sMeasureString = asMeasures[m];
|
|
sMeasureString.TrimLeft();
|
|
sMeasureString.TrimRight();
|
|
|
|
CStringArray asMeasureLines;
|
|
split( sMeasureString, "\n", asMeasureLines, true ); // ignore empty is important
|
|
|
|
//ASSERT( asMeasureLines.GetSize() == 4 ||
|
|
// asMeasureLines.GetSize() == 8 ||
|
|
// asMeasureLines.GetSize() == 12 ||
|
|
// asMeasureLines.GetSize() == 16 );
|
|
|
|
|
|
for( int l=0; l<asMeasureLines.GetSize(); l++ )
|
|
{
|
|
CString &sMeasureLine = asMeasureLines[l];
|
|
sMeasureLine.TrimLeft();
|
|
sMeasureLine.TrimRight();
|
|
|
|
const float fPercentIntoMeasure = l/(float)asMeasureLines.GetSize();
|
|
const float fBeat = (m + fPercentIntoMeasure) * BEATS_PER_MEASURE;
|
|
const int iIndex = BeatToNoteRow( fBeat );
|
|
|
|
if( m_iNumTracks != sMeasureLine.GetLength() )
|
|
throw RageException( "Actual number of note columns (%d) is different from the NotesType (%d).", m_iNumTracks, sMeasureLine.GetLength() );
|
|
|
|
for( int c=0; c<sMeasureLine.GetLength(); c++ )
|
|
m_TapNotes[c][iIndex] = sMeasureLine[c];
|
|
}
|
|
}
|
|
this->Convert2sAnd3sToHoldNotes();
|
|
}
|
|
|
|
CString NoteData::GetSMNoteDataString()
|
|
{
|
|
this->ConvertHoldNotesTo2sAnd3s();
|
|
|
|
float fLastBeat = GetLastBeat();
|
|
int iLastMeasure = int( fLastBeat/BEATS_PER_MEASURE );
|
|
|
|
CStringArray asMeasureStrings;
|
|
|
|
for( int m=0; m<=iLastMeasure; m++ ) // foreach measure
|
|
{
|
|
int iMeasureStartIndex = m * ELEMENTS_PER_MEASURE;
|
|
int iMeasureLastIndex = (m+1) * ELEMENTS_PER_MEASURE - 1;
|
|
|
|
// probe to find the smallest note type
|
|
NoteType nt;
|
|
int iNoteIndexSpacing;
|
|
for( nt=(NoteType)0; nt<NUM_NOTE_TYPES; nt=NoteType(nt+1) )
|
|
{
|
|
float fBeatSpacing = NoteTypeToBeat( nt );
|
|
iNoteIndexSpacing = roundf( fBeatSpacing * ELEMENTS_PER_BEAT );
|
|
|
|
bool bFoundSmallerNote = false;
|
|
for( int i=iMeasureStartIndex; i<=iMeasureLastIndex; i++ ) // for each index in this measure
|
|
{
|
|
if( i % iNoteIndexSpacing == 0 )
|
|
continue; // skip
|
|
|
|
if( !IsRowEmpty(i) )
|
|
{
|
|
bFoundSmallerNote = true;
|
|
break;
|
|
}
|
|
|
|
}
|
|
if( bFoundSmallerNote )
|
|
continue; // keep searching
|
|
else
|
|
break; // stop searching
|
|
}
|
|
|
|
if( nt == NUM_NOTE_TYPES ) // we didn't find one
|
|
iNoteIndexSpacing = 1;
|
|
|
|
|
|
CStringArray asMeasureLines;
|
|
asMeasureLines.Add( ssprintf(" // measure %d", m+1) );
|
|
|
|
for( int i=iMeasureStartIndex; i<=iMeasureLastIndex; i+=iNoteIndexSpacing )
|
|
{
|
|
char szLineString[MAX_NOTE_TRACKS];
|
|
for( int t=0; t<m_iNumTracks; t++ )
|
|
szLineString[t] = m_TapNotes[t][i];
|
|
szLineString[t] = '\0';
|
|
asMeasureLines.Add( szLineString );
|
|
}
|
|
|
|
CString sMeasureString = join( "\n", asMeasureLines );
|
|
|
|
asMeasureStrings.Add( sMeasureString );
|
|
}
|
|
|
|
this->Convert2sAnd3sToHoldNotes();
|
|
|
|
return join( "\n,", asMeasureStrings );
|
|
}
|
|
|
|
|
|
void NoteData::ClearRange( int iNoteIndexBegin, int iNoteIndexEnd )
|
|
{
|
|
// delete old TapNotes in the range
|
|
for( int i=iNoteIndexBegin; i<=iNoteIndexEnd; i++ )
|
|
{
|
|
for( int c=0; c<m_iNumTracks; c++ )
|
|
m_TapNotes[c][i] = '0';
|
|
}
|
|
|
|
// delete old HoldNotes in the range
|
|
int iIndexRead, iIndexWrite = 0;
|
|
const int iOrigNumHoldNotes = m_iNumHoldNotes;
|
|
for( iIndexRead = 0; iIndexRead < iOrigNumHoldNotes; iIndexRead++ )
|
|
{
|
|
HoldNote &hn = m_HoldNotes[iIndexRead];
|
|
if( (hn.m_iStartIndex >= iNoteIndexBegin && hn.m_iStartIndex <= iNoteIndexEnd) ||
|
|
(hn.m_iEndIndex >= iNoteIndexBegin && hn.m_iEndIndex <= iNoteIndexEnd) ) // overlap (kinda)
|
|
{
|
|
; // do nothing
|
|
}
|
|
else // ! overlap
|
|
{
|
|
m_HoldNotes[iIndexWrite] = m_HoldNotes[iIndexRead];
|
|
iIndexWrite++;
|
|
}
|
|
}
|
|
m_iNumHoldNotes = iIndexWrite;
|
|
|
|
}
|
|
|
|
void NoteData::CopyRange( NoteData* pFrom, int iFromIndexBegin, int iFromIndexEnd, int iToIndexBegin )
|
|
{
|
|
ASSERT( pFrom->m_iNumTracks == m_iNumTracks );
|
|
|
|
if( iToIndexBegin == -1 )
|
|
iToIndexBegin = 0;
|
|
|
|
pFrom->ConvertHoldNotesTo2sAnd3s();
|
|
|
|
int f, t;
|
|
|
|
// copy recorded TapNotes
|
|
f = iFromIndexBegin;
|
|
t = iToIndexBegin;
|
|
|
|
while( f<=iFromIndexEnd )
|
|
{
|
|
for( int c=0; c<m_iNumTracks; c++ )
|
|
m_TapNotes[c][t] = pFrom->m_TapNotes[c][f];
|
|
f++;
|
|
t++;
|
|
}
|
|
|
|
pFrom->Convert2sAnd3sToHoldNotes();
|
|
this->Convert2sAnd3sToHoldNotes();
|
|
}
|
|
|
|
void NoteData::AddHoldNote( HoldNote add )
|
|
{
|
|
int i;
|
|
|
|
// look for other hold notes that overlap and merge them
|
|
for( i=0; i<m_iNumHoldNotes; i++ ) // for each HoldNote
|
|
{
|
|
HoldNote &other = m_HoldNotes[i];
|
|
if( add.m_iTrack == other.m_iTrack && // the notes correspond
|
|
other.m_iStartIndex <= add.m_iEndIndex &&
|
|
other.m_iEndIndex >= add.m_iStartIndex ) // these HoldNotes overlap (this isn't entirely correct!)
|
|
{
|
|
add.m_iStartIndex = min(add.m_iStartIndex, other.m_iStartIndex);
|
|
add.m_iEndIndex = max(add.m_iEndIndex, other.m_iEndIndex);
|
|
|
|
// delete this HoldNote
|
|
for( int j=i; j<m_iNumHoldNotes-1; j++ )
|
|
{
|
|
m_HoldNotes[j] = m_HoldNotes[j+1];
|
|
}
|
|
m_iNumHoldNotes--;
|
|
}
|
|
}
|
|
|
|
// delete TapNotes under this HoldNote
|
|
for( i=add.m_iStartIndex+1; i<=add.m_iEndIndex; i++ )
|
|
{
|
|
m_TapNotes[add.m_iTrack][i] = '0';
|
|
};
|
|
|
|
// add a tap note at the start of this hold
|
|
m_TapNotes[add.m_iTrack][add.m_iStartIndex] = '1';
|
|
|
|
ASSERT( m_iNumHoldNotes < MAX_HOLD_NOTES );
|
|
m_HoldNotes[m_iNumHoldNotes++] = add;
|
|
}
|
|
|
|
void NoteData::RemoveHoldNote( int index )
|
|
{
|
|
ASSERT( index > 0 && index < m_iNumHoldNotes );
|
|
|
|
// delete a tap note at the start of this hold
|
|
HoldNote &hn = m_HoldNotes[index];
|
|
m_TapNotes[hn.m_iTrack][hn.m_iStartIndex] = '0';
|
|
|
|
// remove from list
|
|
for( int j=index; j<m_iNumHoldNotes-1; j++ )
|
|
{
|
|
m_HoldNotes[j] = m_HoldNotes[j+1];
|
|
}
|
|
m_iNumHoldNotes--;
|
|
}
|
|
|
|
bool NoteData::IsThereANoteAtRow( int iRow )
|
|
{
|
|
for( int t=0; t<m_iNumTracks; t++ )
|
|
{
|
|
if( m_TapNotes[t][iRow] != '0' )
|
|
return true;
|
|
}
|
|
|
|
for( int i=0; i<m_iNumHoldNotes; i++ ) // for each HoldNote
|
|
{
|
|
if( m_HoldNotes[i].m_iStartIndex == iRow )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
int NoteData::GetFirstRow()
|
|
{
|
|
int iFirstIndexFoundSoFar = MAX_TAP_NOTE_ROWS-1;
|
|
|
|
int i;
|
|
|
|
for( i=0; i<MAX_TAP_NOTE_ROWS, i<iFirstIndexFoundSoFar; i++ ) // iterate back to front
|
|
{
|
|
if( !IsRowEmpty(i) )
|
|
{
|
|
iFirstIndexFoundSoFar = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for( i=0; i<m_iNumHoldNotes; i++ )
|
|
{
|
|
if( m_HoldNotes[i].m_iStartIndex < iFirstIndexFoundSoFar )
|
|
iFirstIndexFoundSoFar = m_HoldNotes[i].m_iStartIndex;
|
|
}
|
|
|
|
|
|
return iFirstIndexFoundSoFar;
|
|
}
|
|
|
|
float NoteData::GetFirstBeat()
|
|
{
|
|
return NoteRowToBeat( GetFirstRow() );
|
|
}
|
|
|
|
int NoteData::GetLastRow()
|
|
{
|
|
int iOldestIndexFoundSoFar = 0;
|
|
|
|
int i;
|
|
|
|
for( i=MAX_TAP_NOTE_ROWS-1; i>=iOldestIndexFoundSoFar; i-- ) // iterate back to front
|
|
{
|
|
if( !IsRowEmpty(i) )
|
|
{
|
|
iOldestIndexFoundSoFar = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for( i=0; i<m_iNumHoldNotes; i++ )
|
|
{
|
|
if( m_HoldNotes[i].m_iEndIndex > iOldestIndexFoundSoFar )
|
|
iOldestIndexFoundSoFar = m_HoldNotes[i].m_iEndIndex;
|
|
}
|
|
|
|
return iOldestIndexFoundSoFar;
|
|
}
|
|
|
|
float NoteData::GetLastBeat()
|
|
{
|
|
return NoteRowToBeat( GetLastRow() );
|
|
}
|
|
|
|
int NoteData::GetNumTapNotes( const float fStartBeat, const float fEndBeat )
|
|
{
|
|
int iNumNotes = 0;
|
|
|
|
int iStartIndex = BeatToNoteRow( fStartBeat );
|
|
int iEndIndex = BeatToNoteRow( fEndBeat );
|
|
|
|
for( int i=iStartIndex; i<min(iEndIndex, MAX_TAP_NOTE_ROWS); i++ )
|
|
{
|
|
for( int t=0; t<m_iNumTracks; t++ )
|
|
{
|
|
if( m_TapNotes[t][i] != '0' )
|
|
iNumNotes++;
|
|
}
|
|
}
|
|
|
|
return iNumNotes;
|
|
}
|
|
|
|
int NoteData::GetNumDoubles( const float fStartBeat, const float fEndBeat )
|
|
{
|
|
int iNumDoubles = 0;
|
|
|
|
int iStartIndex = BeatToNoteRow( fStartBeat );
|
|
int iEndIndex = BeatToNoteRow( fEndBeat );
|
|
|
|
for( int i=iStartIndex; i<min(iEndIndex, MAX_TAP_NOTE_ROWS); i++ )
|
|
{
|
|
int iNumNotesThisIndex = 0;
|
|
for( int t=0; t<m_iNumTracks; t++ )
|
|
{
|
|
if( m_TapNotes[t][i] != '0' )
|
|
iNumNotesThisIndex++;
|
|
}
|
|
if( iNumNotesThisIndex >= 2 )
|
|
iNumDoubles++;
|
|
}
|
|
|
|
return iNumDoubles;
|
|
}
|
|
|
|
int NoteData::GetNumHoldNotes( const float fStartBeat, const float fEndBeat )
|
|
{
|
|
int iNumHolds = 0;
|
|
|
|
int iStartIndex = BeatToNoteRow( fStartBeat );
|
|
int iEndIndex = BeatToNoteRow( fEndBeat );
|
|
|
|
for( int i=0; i<m_iNumHoldNotes; i++ )
|
|
{
|
|
HoldNote &hn = m_HoldNotes[i];
|
|
if( iStartIndex <= hn.m_iStartIndex && hn.m_iEndIndex <= iEndIndex )
|
|
iNumHolds++;
|
|
}
|
|
return iNumHolds;
|
|
}
|
|
|
|
int NoteData::GetPossibleDancePoints()
|
|
{
|
|
//Each song has a certain number of "Dance Points" assigned to it. For regular arrows, this is 2 per arrow. For freeze arrows, it is 6 per arrow. When you add this all up, you get the maximum number of possible "Dance Points".
|
|
//
|
|
//Your "Dance Points" are calculated as follows:
|
|
//
|
|
//A "Perfect" is worth 2 points
|
|
//A "Great" is worth 1 points
|
|
//A "Good" is worth 0 points
|
|
//A "Boo" will subtract 4 points
|
|
//A "Miss" will subtract 8 points
|
|
//An "OK" (Successful Freeze step) will add 6 points
|
|
//A "NG" (Unsuccessful Freeze step) is worth 0 points
|
|
|
|
return GetNumTapNotes()*TapNoteScoreToDancePoints(TNS_PERFECT) +
|
|
GetNumHoldNotes()*HoldNoteScoreToDancePoints(HNS_OK);
|
|
}
|
|
|
|
void NoteData::CropToLeftSide()
|
|
{
|
|
int iFirstRightSideColumn = 4;
|
|
int iLastRightSideColumn = 7;
|
|
|
|
// clear out the right half
|
|
for( int c=iFirstRightSideColumn; c<=iLastRightSideColumn; c++ )
|
|
{
|
|
for( int i=0; i<MAX_TAP_NOTE_ROWS; i++ ) // foreach TapNote
|
|
m_TapNotes[c][i] = '0';
|
|
}
|
|
|
|
for( int i=m_iNumHoldNotes-1; i>=0; i-- ) // foreach HoldNote
|
|
{
|
|
if( c >= iFirstRightSideColumn )
|
|
{
|
|
// delete this HoldNote by shifting everything down
|
|
for( int j=i; j<m_iNumHoldNotes-1; j++ )
|
|
m_HoldNotes[j] = m_HoldNotes[j+1];
|
|
m_iNumHoldNotes--;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void NoteData::CropToRightSide()
|
|
{
|
|
int iFirstRightSideColumn = 4;
|
|
int iLastRightSideColumn = 7;
|
|
|
|
int c;
|
|
|
|
// clear out the left half
|
|
for( c=0; c<iFirstRightSideColumn; c++ )
|
|
{
|
|
for( int i=0; i<MAX_TAP_NOTE_ROWS; i++ ) // foreach TapNote
|
|
m_TapNotes[c][i] = '0';
|
|
}
|
|
|
|
// copy the right side into the left
|
|
for( c=iFirstRightSideColumn; c<=iLastRightSideColumn; c++ )
|
|
{
|
|
for( int i=0; i<MAX_TAP_NOTE_ROWS; i++ ) // foreach TapNote
|
|
{
|
|
m_TapNotes[c-4][i] = m_TapNotes[c][i];
|
|
m_TapNotes[c][i] = '0';
|
|
}
|
|
}
|
|
|
|
for( int i=m_iNumHoldNotes-1; i>=0; i-- ) // foreach HoldNote
|
|
{
|
|
HoldNote &hn = m_HoldNotes[i];
|
|
|
|
if( hn.m_iTrack < iFirstRightSideColumn )
|
|
{
|
|
// delete this HoldNote by shifting everything down
|
|
RemoveHoldNote( i );
|
|
}
|
|
else
|
|
{
|
|
m_HoldNotes[i].m_iTrack -= 4;
|
|
}
|
|
}
|
|
}
|
|
|
|
void NoteData::RemoveHoldNotes()
|
|
{
|
|
// turn all the HoldNotes into TapNotes
|
|
for( int i=0; i<m_iNumHoldNotes; i++ )
|
|
{
|
|
HoldNote &hn = m_HoldNotes[i];
|
|
|
|
int iIndex = hn.m_iStartIndex;
|
|
int iCol = hn.m_iTrack;
|
|
|
|
m_TapNotes[iCol][iIndex] = '1';
|
|
}
|
|
|
|
// Remove all HoldNotes
|
|
m_iNumHoldNotes = 0;
|
|
}
|
|
|
|
|
|
void NoteData::Turn( PlayerOptions::TurnType tt )
|
|
{
|
|
// transform the NoteData
|
|
int oldColToNewCol[12][2]; // 0 is old Step, 1 is new Step mapping
|
|
oldColToNewCol[0][0] = 0; oldColToNewCol[0][1] = 0;
|
|
oldColToNewCol[1][0] = 1; oldColToNewCol[1][1] = 1;
|
|
oldColToNewCol[2][0] = 2; oldColToNewCol[2][1] = 2;
|
|
oldColToNewCol[3][0] = 3; oldColToNewCol[3][1] = 3;
|
|
oldColToNewCol[4][0] = 4; oldColToNewCol[4][1] = 4;
|
|
oldColToNewCol[5][0] = 5; oldColToNewCol[5][1] = 5;
|
|
oldColToNewCol[6][0] = 6; oldColToNewCol[6][1] = 6;
|
|
oldColToNewCol[7][0] = 7; oldColToNewCol[7][1] = 7;
|
|
oldColToNewCol[8][0] = 8; oldColToNewCol[8][1] = 8;
|
|
oldColToNewCol[9][0] = 9; oldColToNewCol[9][1] = 9;
|
|
oldColToNewCol[10][0]= 10; oldColToNewCol[10][1]= 10;
|
|
oldColToNewCol[11][0]= 11; oldColToNewCol[11][1]= 11;
|
|
|
|
switch( tt )
|
|
{
|
|
case PlayerOptions::TURN_NONE:
|
|
break;
|
|
case PlayerOptions::TURN_MIRROR:
|
|
oldColToNewCol[0][1] = 3;
|
|
oldColToNewCol[2][1] = 2;
|
|
oldColToNewCol[3][1] = 1;
|
|
oldColToNewCol[5][1] = 0;
|
|
oldColToNewCol[6][1] = 7;
|
|
oldColToNewCol[8][1] = 6;
|
|
oldColToNewCol[9][1] = 5;
|
|
oldColToNewCol[11][1]= 4;
|
|
break;
|
|
case PlayerOptions::TURN_LEFT:
|
|
oldColToNewCol[0][1] = 1;
|
|
oldColToNewCol[2][1] = 3;
|
|
oldColToNewCol[3][1] = 0;
|
|
oldColToNewCol[5][1] = 2;
|
|
oldColToNewCol[6][1] = 5;
|
|
oldColToNewCol[8][1] = 7;
|
|
oldColToNewCol[9][1] = 4;
|
|
oldColToNewCol[11][1]= 6;
|
|
break;
|
|
case PlayerOptions::TURN_RIGHT:
|
|
oldColToNewCol[0][1] = 3;
|
|
oldColToNewCol[2][1] = 0;
|
|
oldColToNewCol[3][1] = 4;
|
|
oldColToNewCol[5][1] = 1;
|
|
oldColToNewCol[6][1] = 6;
|
|
oldColToNewCol[8][1] = 4;
|
|
oldColToNewCol[9][1] = 7;
|
|
oldColToNewCol[11][1]= 5;
|
|
break;
|
|
case PlayerOptions::TURN_SHUFFLE:
|
|
bool bAlreadyMapped[12];
|
|
for( int i=0; i<12; i++ )
|
|
bAlreadyMapped[i] = false;
|
|
|
|
// hack: don't shuffle the Up+... NoteData
|
|
bAlreadyMapped[1] = true;
|
|
bAlreadyMapped[4] = true;
|
|
bAlreadyMapped[7] = true;
|
|
bAlreadyMapped[10] = true;
|
|
|
|
// shuffle left side
|
|
for( i=0; i<6; i++ )
|
|
{
|
|
if( i == 1 || i == 4 )
|
|
continue;
|
|
|
|
int iMapsTo;
|
|
do {
|
|
iMapsTo = rand()%6;
|
|
} while( bAlreadyMapped[iMapsTo] );
|
|
bAlreadyMapped[iMapsTo] = true;
|
|
|
|
oldColToNewCol[i][1] = oldColToNewCol[iMapsTo][0];
|
|
}
|
|
// shuffle right side
|
|
for( i=6; i<12; i++ )
|
|
{
|
|
if( i == 7 || i == 10 )
|
|
continue;
|
|
|
|
int iMapsTo;
|
|
do {
|
|
iMapsTo = rand()%6+6;
|
|
} while( bAlreadyMapped[iMapsTo] );
|
|
bAlreadyMapped[iMapsTo] = true;
|
|
|
|
oldColToNewCol[i][1] = oldColToNewCol[iMapsTo][0];
|
|
}
|
|
break;
|
|
}
|
|
|
|
NoteData tempNoteData; // write into here as we tranform
|
|
tempNoteData.m_iNumTracks = m_iNumTracks;
|
|
|
|
// transform m_TapNotes
|
|
for( int i=0; i<MAX_TAP_NOTE_ROWS; i++ )
|
|
{
|
|
for( int j=0; j<12; j++ )
|
|
{
|
|
int iOldCol = oldColToNewCol[j][0];
|
|
int iNewCol = oldColToNewCol[j][1];
|
|
|
|
tempNoteData.m_TapNotes[iNewCol][i] = m_TapNotes[iOldCol][i];
|
|
}
|
|
}
|
|
|
|
// transform m_HoldNotes
|
|
for( i=0; i<m_iNumHoldNotes; i++ )
|
|
{
|
|
for( int j=0; j<12; j++ )
|
|
{
|
|
HoldNote &hn = m_HoldNotes[i];
|
|
|
|
int iOldCol = oldColToNewCol[j][0];
|
|
int iNewCol = oldColToNewCol[j][1];
|
|
|
|
if( hn.m_iTrack == iOldCol )
|
|
{
|
|
HoldNote newHN = { iNewCol, hn.m_iStartIndex, hn.m_iEndIndex };
|
|
tempNoteData.AddHoldNote( newHN );
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// copy note data from newData back into this
|
|
//
|
|
(*this) = tempNoteData;
|
|
}
|
|
|
|
void NoteData::MakeLittle()
|
|
{
|
|
// filter out all non-quarter notes
|
|
for( int i=0; i<MAX_TAP_NOTE_ROWS; i++ )
|
|
{
|
|
if( i%ELEMENTS_PER_BEAT != 0 )
|
|
{
|
|
// filter out all non-quarter notes
|
|
for( int c=0; c<m_iNumTracks; c++ )
|
|
{
|
|
m_TapNotes[c][i] = '0';
|
|
}
|
|
}
|
|
}
|
|
|
|
// leave HoldNotes unchanged (what should be do with them?)
|
|
}
|
|
|
|
void NoteData::Convert2sAnd3sToHoldNotes()
|
|
{
|
|
// Any note will end a hold (not just a '3'). This makes parsing DWIs much easier,
|
|
// plus we don't want tap notes in the middle of a hold!
|
|
|
|
for( int col=0; col<m_iNumTracks; col++ ) // foreach column
|
|
{
|
|
for( int i=0; i<MAX_TAP_NOTE_ROWS; i++ ) // foreach TapNote element
|
|
{
|
|
if( m_TapNotes[col][i] == '2' ) // this is a HoldNote begin marker
|
|
{
|
|
for( int j=i+1; j<MAX_TAP_NOTE_ROWS; j++ ) // search for end of HoldNote
|
|
{
|
|
if( m_TapNotes[col][j] != '0' ) // end hold on the next note we see
|
|
{
|
|
HoldNote hn = { col, i, j };
|
|
AddHoldNote( hn );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void NoteData::ConvertHoldNotesTo2sAnd3s()
|
|
{
|
|
// copy HoldNotes into the new structure, but expand them into 2s and 3s
|
|
for( int i=0; i<m_iNumHoldNotes; i++ )
|
|
{
|
|
HoldNote &hn = m_HoldNotes[i];
|
|
m_TapNotes[hn.m_iTrack][hn.m_iStartIndex] = '2';
|
|
m_TapNotes[hn.m_iTrack][hn.m_iEndIndex] = '3';
|
|
}
|
|
m_iNumHoldNotes = 0;
|
|
}
|
|
|
|
void NoteData::SnapToNearestNoteType( NoteType nt1, NoteType nt2, float fBeginBeat, float fEndBeat )
|
|
{
|
|
// nt2 is optional and should be -1 if it is not used
|
|
|
|
float fSnapInterval1, fSnapInterval2;
|
|
switch( nt1 )
|
|
{
|
|
case NOTE_4TH: fSnapInterval1 = 1/1.0f; break;
|
|
case NOTE_8TH: fSnapInterval1 = 1/2.0f; break;
|
|
case NOTE_12TH: fSnapInterval1 = 1/3.0f; break;
|
|
case NOTE_16TH: fSnapInterval1 = 1/4.0f; break;
|
|
default: ASSERT( false );
|
|
}
|
|
|
|
switch( nt2 )
|
|
{
|
|
case NOTE_4TH: fSnapInterval2 = 1/1.0f; break;
|
|
case NOTE_8TH: fSnapInterval2 = 1/2.0f; break;
|
|
case NOTE_12TH: fSnapInterval2 = 1/3.0f; break;
|
|
case NOTE_16TH: fSnapInterval2 = 1/4.0f; break;
|
|
case -1: fSnapInterval2 = 10000; break; // nothing will ever snap to this. That is good!
|
|
default: ASSERT( false );
|
|
}
|
|
|
|
int iNoteIndexBegin = BeatToNoteRow( fBeginBeat );
|
|
int iNoteIndexEnd = BeatToNoteRow( fEndBeat );
|
|
|
|
//ConvertHoldNotesTo2sAnd3s();
|
|
|
|
// iterate over all TapNotes in the interval and snap them
|
|
for( int i=iNoteIndexBegin; i<=iNoteIndexEnd; i++ )
|
|
{
|
|
int iOldIndex = i;
|
|
float fOldBeat = NoteRowToBeat( iOldIndex );
|
|
float fNewBeat1 = froundf( fOldBeat, fSnapInterval1 );
|
|
float fNewBeat2 = froundf( fOldBeat, fSnapInterval2 );
|
|
|
|
bool bNewBeat1IsCloser = fabsf(fNewBeat1-fOldBeat) < fabsf(fNewBeat2-fOldBeat);
|
|
float fNewBeat = bNewBeat1IsCloser ? fNewBeat1 : fNewBeat2;
|
|
int iNewIndex = BeatToNoteRow( fNewBeat );
|
|
|
|
for( int c=0; c<m_iNumTracks; c++ )
|
|
{
|
|
TapNote note = m_TapNotes[c][iOldIndex];
|
|
m_TapNotes[c][iOldIndex] = '0';
|
|
m_TapNotes[c][iNewIndex] = max( m_TapNotes[c][iNewIndex], note ); // this causes HoldNotes to override TapNotes
|
|
}
|
|
}
|
|
|
|
//Convert2sAnd3sToHoldNotes();
|
|
}
|
|
|
|
|
|
float NoteData::GetStreamRadarValue( float fSongSeconds )
|
|
{
|
|
// density of steps
|
|
int iNumNotes = GetNumTapNotes() + GetNumHoldNotes();
|
|
float fNotesPerSecond = iNumNotes/fSongSeconds;
|
|
float fReturn = fNotesPerSecond / 7;
|
|
return min( fReturn, 1.0f );
|
|
}
|
|
|
|
float NoteData::GetVoltageRadarValue( float fSongSeconds )
|
|
{
|
|
float fAvgBPS = GetLastBeat() / fSongSeconds;
|
|
|
|
// peak density of steps
|
|
float fMaxDensitySoFar = 0;
|
|
|
|
const int BEAT_WINDOW = 8;
|
|
|
|
for( int i=0; i<MAX_BEATS; i+=BEAT_WINDOW )
|
|
{
|
|
int iNumNotesThisWindow = GetNumTapNotes((float)i,(float)i+BEAT_WINDOW) + GetNumHoldNotes((float)i,(float)i+BEAT_WINDOW);
|
|
float fDensityThisWindow = iNumNotesThisWindow/(float)BEAT_WINDOW;
|
|
fMaxDensitySoFar = max( fMaxDensitySoFar, fDensityThisWindow );
|
|
}
|
|
|
|
float fReturn = fMaxDensitySoFar*fAvgBPS/10;
|
|
return min( fReturn, 1.0f );
|
|
}
|
|
|
|
float NoteData::GetAirRadarValue( float fSongSeconds )
|
|
{
|
|
// number of doubles
|
|
int iNumDoubles = GetNumDoubles();
|
|
float fReturn = iNumDoubles / fSongSeconds;
|
|
return min( fReturn, 1.0f );
|
|
}
|
|
|
|
float NoteData::GetChaosRadarValue( float fSongSeconds )
|
|
{
|
|
// count number of triplets or 16ths
|
|
int iNumChaosNotes = 0;
|
|
for( int r=0; r<MAX_TAP_NOTE_ROWS; r++ )
|
|
{
|
|
if( !IsRowEmpty(r) && GetNoteType(r) >= NOTE_12TH )
|
|
iNumChaosNotes++;
|
|
}
|
|
|
|
float fReturn = iNumChaosNotes / fSongSeconds * 0.5f;
|
|
return min( fReturn, 1.0f );
|
|
}
|
|
|
|
float NoteData::GetFreezeRadarValue( float fSongSeconds )
|
|
{
|
|
// number of hold steps
|
|
float fReturn = GetNumHoldNotes() / fSongSeconds;
|
|
return min( fReturn, 1.0f );
|
|
}
|
|
|
|
|
|
void NoteData::LoadTransformed( NoteData* pOriginal, int iNewNumTracks, int iNewToOriginalTrack[] )
|
|
{
|
|
// init
|
|
Init();
|
|
|
|
m_iNumTracks = iNewNumTracks;
|
|
|
|
// copy tracks
|
|
for( int t=0; t<m_iNumTracks; t++ )
|
|
{
|
|
int iOriginalTrack = iNewToOriginalTrack[t];
|
|
|
|
int i;
|
|
|
|
memcpy( m_TapNotes[t], pOriginal->m_TapNotes[iOriginalTrack], MAX_TAP_NOTE_ROWS*sizeof(m_TapNotes[0][0]) );
|
|
|
|
for( i=0; i<pOriginal->m_iNumHoldNotes; i++ )
|
|
{
|
|
HoldNote &hn = pOriginal->m_HoldNotes[i];
|
|
if( hn.m_iTrack == iOriginalTrack )
|
|
{
|
|
hn.m_iTrack = t;
|
|
this->AddHoldNote( hn );
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|