Chris Danford
892 lines
23 KiB
C++
892 lines
23 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"
|
|
#include "GameState.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
|
|
{
|
|
NoteType nt = GetSmallestNoteTypeForMeasure( m );
|
|
int iRowSpacing;
|
|
if( nt == NOTE_TYPE_INVALID )
|
|
iRowSpacing = 1;
|
|
else
|
|
iRowSpacing = int(roundf( NoteTypeToBeat(nt) * ROWS_PER_BEAT ));
|
|
|
|
CStringArray asMeasureLines;
|
|
asMeasureLines.Add( ssprintf(" // measure %d", m+1) );
|
|
|
|
const int iMeasureStartRow = m * ROWS_PER_MEASURE;
|
|
const int iMeasureLastRow = (m+1) * ROWS_PER_MEASURE - 1;
|
|
|
|
for( int r=iMeasureStartRow; r<=iMeasureLastRow; r+=iRowSpacing )
|
|
{
|
|
char szLineString[MAX_NOTE_TRACKS];
|
|
for( int t=0; t<m_iNumTracks; t++ )
|
|
szLineString[t] = m_TapNotes[t][r];
|
|
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 )
|
|
{
|
|
this->ConvertHoldNotesTo4s();
|
|
for( int c=0; c<m_iNumTracks; c++ )
|
|
{
|
|
for( int i=iNoteIndexBegin; i<=iNoteIndexEnd; i++ )
|
|
m_TapNotes[c][i] = '0';
|
|
}
|
|
this->Convert4sToHoldNotes();
|
|
}
|
|
|
|
/* Copy a range from pFrom to this. (Note that this does *not* overlay;
|
|
* all data in the range is overwritten.) */
|
|
void NoteData::CopyRange( NoteData* pFrom, int iFromIndexBegin, int iFromIndexEnd, int iToIndexBegin )
|
|
{
|
|
ASSERT( pFrom->m_iNumTracks == m_iNumTracks );
|
|
|
|
if( iToIndexBegin == -1 )
|
|
iToIndexBegin = 0;
|
|
|
|
pFrom->ConvertHoldNotesTo4s();
|
|
this->ConvertHoldNotesTo4s();
|
|
|
|
// copy recorded TapNotes
|
|
int 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->Convert4sToHoldNotes();
|
|
this->Convert4sToHoldNotes();
|
|
}
|
|
|
|
void NoteData::AddHoldNote( HoldNote add )
|
|
{
|
|
ASSERT( add.m_fStartBeat>=0 && add.m_fEndBeat>=0 );
|
|
|
|
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_fStartBeat <= add.m_fEndBeat &&
|
|
other.m_fEndBeat >= add.m_fStartBeat ) // these HoldNotes overlap (this isn't entirely correct!)
|
|
{
|
|
add.m_fStartBeat = min(add.m_fStartBeat, other.m_fStartBeat);
|
|
add.m_fEndBeat = max(add.m_fEndBeat, other.m_fEndBeat);
|
|
|
|
// delete this HoldNote
|
|
for( int j=i; j<m_iNumHoldNotes-1; j++ )
|
|
m_HoldNotes[j] = m_HoldNotes[j+1];
|
|
|
|
m_iNumHoldNotes--;
|
|
}
|
|
}
|
|
|
|
int iAddStartIndex = BeatToNoteRow(add.m_fStartBeat);
|
|
int iAddEndIndex = BeatToNoteRow(add.m_fEndBeat);
|
|
|
|
// delete TapNotes under this HoldNote
|
|
for( i=iAddStartIndex+1; i<=iAddEndIndex; i++ )
|
|
m_TapNotes[add.m_iTrack][i] = '0';
|
|
|
|
// add a tap note at the start of this hold
|
|
m_TapNotes[add.m_iTrack][iAddStartIndex] = '2'; // '2' means a Hold begin marker. Don't draw this, but do grade it.
|
|
|
|
ASSERT( m_iNumHoldNotes < MAX_HOLD_NOTES );
|
|
m_HoldNotes[m_iNumHoldNotes++] = add;
|
|
}
|
|
|
|
void NoteData::RemoveHoldNote( int iHoldIndex )
|
|
{
|
|
ASSERT( iHoldIndex >= 0 && iHoldIndex < m_iNumHoldNotes );
|
|
|
|
HoldNote& hn = m_HoldNotes[iHoldIndex];
|
|
|
|
int iHoldStartIndex = BeatToNoteRow(hn.m_fStartBeat);
|
|
|
|
// delete a tap note at the start of this hold
|
|
m_TapNotes[hn.m_iTrack][iHoldStartIndex] = '0';
|
|
|
|
// remove from list
|
|
for( int j=iHoldIndex; 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;
|
|
|
|
// There is a tap note at the beginning of every HoldNote start
|
|
//
|
|
// for( int i=0; i<m_iNumHoldNotes; i++ ) // for each HoldNote
|
|
// if( m_HoldNotes[i].m_iStartIndex == NoteRowToBeatRow(iRow) )
|
|
// return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
int NoteData::GetFirstRow()
|
|
{
|
|
return BeatToNoteRow( GetFirstBeat() );
|
|
}
|
|
|
|
float NoteData::GetFirstBeat()
|
|
{
|
|
float fEarliestBeatFoundSoFar = MAX_BEATS;
|
|
|
|
int i;
|
|
|
|
for( i=0; i<MAX_TAP_NOTE_ROWS; i++ )
|
|
{
|
|
if( !IsRowEmpty(i) )
|
|
{
|
|
fEarliestBeatFoundSoFar = NoteRowToBeat(i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
for( i=0; i<m_iNumHoldNotes; i++ )
|
|
if( m_HoldNotes[i].m_fStartBeat < fEarliestBeatFoundSoFar )
|
|
fEarliestBeatFoundSoFar = m_HoldNotes[i].m_fStartBeat;
|
|
|
|
|
|
if( fEarliestBeatFoundSoFar == MAX_BEATS ) // there are no notes
|
|
return 0;
|
|
else
|
|
return fEarliestBeatFoundSoFar;
|
|
}
|
|
|
|
int NoteData::GetLastRow()
|
|
{
|
|
return BeatToNoteRow( GetLastBeat() );
|
|
}
|
|
|
|
float NoteData::GetLastBeat()
|
|
{
|
|
float fOldestBeatFoundSoFar = 0;
|
|
|
|
int i;
|
|
|
|
for( i=MAX_TAP_NOTE_ROWS-1; i>=0; i-- ) // iterate back to front
|
|
{
|
|
if( !IsRowEmpty(i) )
|
|
{
|
|
fOldestBeatFoundSoFar = NoteRowToBeat(i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
for( i=0; i<m_iNumHoldNotes; i++ )
|
|
{
|
|
if( m_HoldNotes[i].m_fEndBeat > fOldestBeatFoundSoFar )
|
|
fOldestBeatFoundSoFar = m_HoldNotes[i].m_fEndBeat;
|
|
}
|
|
|
|
return fOldestBeatFoundSoFar;
|
|
}
|
|
|
|
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;
|
|
|
|
for( int i=0; i<m_iNumHoldNotes; i++ )
|
|
{
|
|
HoldNote &hn = m_HoldNotes[i];
|
|
if( fStartBeat <= hn.m_fStartBeat && hn.m_fEndBeat <= fEndBeat )
|
|
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 = BeatToNoteRow(hn.m_fStartBeat);
|
|
int iCol = hn.m_iTrack;
|
|
|
|
m_TapNotes[iCol][iIndex] = '1';
|
|
}
|
|
|
|
// Remove all HoldNotes
|
|
m_iNumHoldNotes = 0;
|
|
}
|
|
|
|
|
|
void NoteData::Turn( PlayerOptions::TurnType tt )
|
|
{
|
|
int iTakeFromTrack[MAX_NOTE_TRACKS]; // New track "t" will take from old track iTakeFromTrack[t]
|
|
|
|
int t;
|
|
|
|
switch( tt )
|
|
{
|
|
case PlayerOptions::TURN_NONE:
|
|
return; // nothing to do
|
|
case PlayerOptions::TURN_MIRROR:
|
|
for( t=0; t<m_iNumTracks; t++ )
|
|
iTakeFromTrack[t] = m_iNumTracks-t-1;
|
|
break;
|
|
case PlayerOptions::TURN_LEFT:
|
|
case PlayerOptions::TURN_RIGHT: // HACK: TurnRight does the same thing as TurnLeft. I'll fix this later...
|
|
// Chris: Handling each NotesType case is a terrible way to do this, but oh well...
|
|
/* XXX: This assumes each NotesType in a style turns the same. */
|
|
switch( GAMESTATE->GetCurrentStyleDef()->m_NotesTypes[0] )
|
|
{
|
|
case NOTES_TYPE_DANCE_SINGLE:
|
|
case NOTES_TYPE_DANCE_DOUBLE:
|
|
case NOTES_TYPE_DANCE_COUPLE:
|
|
iTakeFromTrack[0] = 2;
|
|
iTakeFromTrack[1] = 0;
|
|
iTakeFromTrack[2] = 3;
|
|
iTakeFromTrack[3] = 1;
|
|
iTakeFromTrack[4] = 6;
|
|
iTakeFromTrack[5] = 4;
|
|
iTakeFromTrack[6] = 7;
|
|
iTakeFromTrack[7] = 5;
|
|
break;
|
|
case NOTES_TYPE_DANCE_SOLO:
|
|
iTakeFromTrack[0] = 5;
|
|
iTakeFromTrack[1] = 4;
|
|
iTakeFromTrack[2] = 0;
|
|
iTakeFromTrack[3] = 3;
|
|
iTakeFromTrack[4] = 1;
|
|
iTakeFromTrack[5] = 2;
|
|
break;
|
|
case NOTES_TYPE_PUMP_SINGLE:
|
|
case NOTES_TYPE_PUMP_DOUBLE:
|
|
case NOTES_TYPE_PUMP_COUPLE:
|
|
iTakeFromTrack[0] = 1;
|
|
iTakeFromTrack[1] = 3;
|
|
iTakeFromTrack[2] = 2;
|
|
iTakeFromTrack[3] = 4;
|
|
iTakeFromTrack[4] = 0;
|
|
iTakeFromTrack[5] = 6;
|
|
iTakeFromTrack[6] = 8;
|
|
iTakeFromTrack[7] = 7;
|
|
iTakeFromTrack[8] = 9;
|
|
iTakeFromTrack[9] = 5;
|
|
break;
|
|
case NOTES_TYPE_EZ2_SINGLE:
|
|
case NOTES_TYPE_EZ2_DOUBLE:
|
|
case NOTES_TYPE_EZ2_REAL:
|
|
// identity transform. What should we do here?
|
|
iTakeFromTrack[0] = 0;
|
|
iTakeFromTrack[1] = 1;
|
|
iTakeFromTrack[2] = 2;
|
|
iTakeFromTrack[3] = 3;
|
|
iTakeFromTrack[4] = 4;
|
|
iTakeFromTrack[5] = 5;
|
|
iTakeFromTrack[6] = 6;
|
|
iTakeFromTrack[7] = 7;
|
|
iTakeFromTrack[8] = 8;
|
|
iTakeFromTrack[9] = 9;
|
|
iTakeFromTrack[10]= 10;
|
|
iTakeFromTrack[11]= 11;
|
|
break;
|
|
}
|
|
break;
|
|
case PlayerOptions::TURN_SHUFFLE:
|
|
{
|
|
CArray<int,int> aiTracksLeftToMap;
|
|
for( t=0; t<m_iNumTracks; t++ )
|
|
aiTracksLeftToMap.Add( t );
|
|
|
|
for( t=0; t<m_iNumTracks; t++ )
|
|
{
|
|
int iRandTrackIndex = rand()%aiTracksLeftToMap.GetSize();
|
|
int iRandTrack = aiTracksLeftToMap[iRandTrackIndex];
|
|
aiTracksLeftToMap.RemoveAt( iRandTrackIndex );
|
|
iTakeFromTrack[t] = iRandTrack;
|
|
}
|
|
}
|
|
break;
|
|
case PlayerOptions::TURN_SUPER_SHUFFLE:
|
|
// handle this below
|
|
break;
|
|
default:
|
|
ASSERT(0);
|
|
}
|
|
|
|
NoteData tempNoteData; // write into here as we tranform
|
|
tempNoteData.m_iNumTracks = m_iNumTracks;
|
|
|
|
this->ConvertHoldNotesTo2sAnd3s();
|
|
|
|
// transform notes
|
|
for( t=0; t<m_iNumTracks; t++ )
|
|
for( int r=0; r<MAX_TAP_NOTE_ROWS; r++ )
|
|
tempNoteData.m_TapNotes[t][r] = m_TapNotes[iTakeFromTrack[t]][r];
|
|
|
|
|
|
if( tt == PlayerOptions::TURN_SUPER_SHUFFLE )
|
|
{
|
|
this->Convert2sAnd3sToHoldNotes(); // so we don't super-shuffle HoldNotes
|
|
for( int r=0; r<this->GetLastRow(); r++ ) // foreach row
|
|
{
|
|
if( !this->IsRowEmpty(r) )
|
|
{
|
|
// shuffle this row
|
|
CArray<int,int> aiTracksLeftToMap;
|
|
for( t=0; t<m_iNumTracks; t++ )
|
|
aiTracksLeftToMap.Add( t );
|
|
|
|
for( t=0; t<m_iNumTracks; t++ )
|
|
{
|
|
int iRandTrackIndex = rand()%aiTracksLeftToMap.GetSize();
|
|
int iRandTrack = aiTracksLeftToMap[iRandTrackIndex];
|
|
aiTracksLeftToMap.RemoveAt( iRandTrackIndex );
|
|
iTakeFromTrack[t] = iRandTrack;
|
|
}
|
|
|
|
for( t=0; t<m_iNumTracks; t++ )
|
|
tempNoteData.m_TapNotes[t][r] = m_TapNotes[iTakeFromTrack[t]][r];
|
|
}
|
|
}
|
|
for( int i=0; i<this->m_iNumHoldNotes; i++ )
|
|
{
|
|
HoldNote& hn = this->m_HoldNotes[i];
|
|
HoldNote newHN = hn;
|
|
hn.m_iTrack = rand() % m_iNumTracks;
|
|
tempNoteData.AddHoldNote( newHN );
|
|
}
|
|
}
|
|
|
|
this->CopyAll( &tempNoteData ); // copy note data from newData back into this
|
|
this->Convert2sAnd3sToHoldNotes();
|
|
}
|
|
|
|
void NoteData::MakeLittle()
|
|
{
|
|
// filter out all non-quarter notes
|
|
for( int i=0; i<MAX_TAP_NOTE_ROWS; i++ )
|
|
{
|
|
if( i%ROWS_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?)
|
|
}
|
|
|
|
/* ConvertHoldNotesTo2sAnd3s also clears m_iNumHoldNotes;
|
|
* shouldn't this do likewise and set all 2/3's to 0?
|
|
* -glenn
|
|
*
|
|
* Other code assumes != '0' means there's a tap note, so I changed
|
|
* this to do this. -glenn
|
|
*
|
|
|
|
*/
|
|
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
|
|
continue;
|
|
m_TapNotes[col][i] = '0';
|
|
|
|
for( int j=i+1; j<MAX_TAP_NOTE_ROWS; j++ ) // search for end of HoldNote
|
|
{
|
|
// end hold on the next note we see
|
|
if( m_TapNotes[col][j] == '0' )
|
|
continue;
|
|
|
|
m_TapNotes[col][j] = '0';
|
|
|
|
HoldNote hn = { col, NoteRowToBeat(i), NoteRowToBeat(j) };
|
|
AddHoldNote( hn );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* "102000301" ==
|
|
* "104444001" */
|
|
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];
|
|
int iHoldStartIndex = BeatToNoteRow(hn.m_fStartBeat);
|
|
int iHoldEndIndex = BeatToNoteRow(hn.m_fEndBeat);
|
|
m_TapNotes[hn.m_iTrack][iHoldStartIndex] = '2';
|
|
m_TapNotes[hn.m_iTrack][iHoldEndIndex] = '3';
|
|
}
|
|
m_iNumHoldNotes = 0;
|
|
}
|
|
|
|
/* "104444001" ==
|
|
* "102000301"
|
|
*
|
|
* "4441" basically means "hold for three rows then hold for another tap";
|
|
* since taps don't really have a length, it's equivalent to "4440".
|
|
* So, make sure the character after a 4 is always a 0. */
|
|
void NoteData::Convert4sToHoldNotes()
|
|
{
|
|
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] != '4' ) // this is a HoldNote begin marker
|
|
continue;
|
|
|
|
HoldNote hn = { col, NoteRowToBeat(i), 0 };
|
|
// search for end of HoldNote
|
|
do {
|
|
m_TapNotes[col][i] = '0';
|
|
i++;
|
|
} while( i<MAX_TAP_NOTE_ROWS && m_TapNotes[col][i] == '4');
|
|
m_TapNotes[col][i] = '0';
|
|
|
|
hn.m_fEndBeat = NoteRowToBeat(i);
|
|
AddHoldNote( hn );
|
|
}
|
|
}
|
|
}
|
|
|
|
void NoteData::ConvertHoldNotesTo4s()
|
|
{
|
|
// copy HoldNotes into the new structure, but expand them into 4s
|
|
for( int i=0; i<m_iNumHoldNotes; i++ )
|
|
{
|
|
HoldNote &hn = m_HoldNotes[i];
|
|
int iHoldStartIndex = BeatToNoteRow(hn.m_fStartBeat);
|
|
int iHoldEndIndex = BeatToNoteRow(hn.m_fEndBeat);
|
|
for( int j = iHoldStartIndex; j < iHoldEndIndex; ++j)
|
|
m_TapNotes[hn.m_iTrack][j] = '4';
|
|
}
|
|
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_TYPE_4TH: fSnapInterval1 = 1/1.0f; break;
|
|
case NOTE_TYPE_8TH: fSnapInterval1 = 1/2.0f; break;
|
|
case NOTE_TYPE_12TH: fSnapInterval1 = 1/3.0f; break;
|
|
case NOTE_TYPE_16TH: fSnapInterval1 = 1/4.0f; break;
|
|
default: ASSERT( false ); return;
|
|
}
|
|
|
|
switch( nt2 )
|
|
{
|
|
case NOTE_TYPE_4TH: fSnapInterval2 = 1/1.0f; break;
|
|
case NOTE_TYPE_8TH: fSnapInterval2 = 1/2.0f; break;
|
|
case NOTE_TYPE_12TH: fSnapInterval2 = 1/3.0f; break;
|
|
case NOTE_TYPE_16TH: fSnapInterval2 = 1/4.0f; break;
|
|
case -1: fSnapInterval2 = 10000; break; // nothing will ever snap to this. That's what we want!
|
|
default: ASSERT( false ); return;
|
|
}
|
|
|
|
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_TYPE_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 );
|
|
}
|
|
|
|
|
|
// -1 for iOriginalTracksToTakeFrom means no track
|
|
void NoteData::LoadTransformed( NoteData* pOriginal, int iNewNumTracks, const int iOriginalTrackToTakeFrom[] )
|
|
{
|
|
pOriginal->ConvertHoldNotesTo4s();
|
|
|
|
// reset all notes
|
|
Init();
|
|
|
|
m_iNumTracks = iNewNumTracks;
|
|
|
|
// copy tracks
|
|
for( int t=0; t<m_iNumTracks; t++ )
|
|
{
|
|
const int iOriginalTrack = iOriginalTrackToTakeFrom[t];
|
|
ASSERT( iOriginalTrack < pOriginal->m_iNumTracks );
|
|
if( iOriginalTrack == -1 )
|
|
continue;
|
|
memcpy( m_TapNotes[t], pOriginal->m_TapNotes[iOriginalTrack], MAX_TAP_NOTE_ROWS*sizeof(m_TapNotes[0][0]) );
|
|
}
|
|
|
|
pOriginal->Convert4sToHoldNotes();
|
|
Convert4sToHoldNotes();
|
|
}
|
|
|
|
NoteType NoteData::GetSmallestNoteTypeForMeasure( int iMeasureIndex )
|
|
{
|
|
const int iMeasureStartIndex = iMeasureIndex * ROWS_PER_MEASURE;
|
|
const int iMeasureLastIndex = (iMeasureIndex+1) * ROWS_PER_MEASURE - 1;
|
|
|
|
// probe to find the smallest note type
|
|
NoteType nt;
|
|
for( nt=(NoteType)0; nt<NUM_NOTE_TYPES; nt=NoteType(nt+1) ) // for each NoteType, largest to largest
|
|
{
|
|
float fBeatSpacing = NoteTypeToBeat( nt );
|
|
int iRowSpacing = int(roundf( fBeatSpacing * ROWS_PER_BEAT ));
|
|
|
|
bool bFoundSmallerNote = false;
|
|
for( int i=iMeasureStartIndex; i<=iMeasureLastIndex; i++ ) // for each index in this measure
|
|
{
|
|
if( i % iRowSpacing == 0 )
|
|
continue; // skip
|
|
|
|
if( !IsRowEmpty(i) )
|
|
{
|
|
bFoundSmallerNote = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( bFoundSmallerNote )
|
|
continue; // searching the next NoteType
|
|
else
|
|
break; // stop searching. We found the smallest NoteType
|
|
}
|
|
|
|
if( nt == NUM_NOTE_TYPES ) // we didn't find one
|
|
return NOTE_TYPE_INVALID; // well-formed notes created in the editor should never get here
|
|
else
|
|
return nt;
|
|
} |