Chris Danford
942 lines
26 KiB
C++
942 lines
26 KiB
C++
#include "stdafx.h"
|
|
/*
|
|
-----------------------------------------------------------------------------
|
|
Class: ScreenEdit
|
|
|
|
Desc: See header.
|
|
|
|
Copyright (c) 2001-2002 by the person(s) listed below. All rights reserved.
|
|
Chris Danford
|
|
-----------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "ScreenEdit.h"
|
|
#include "PrefsManager.h"
|
|
#include "SongManager.h"
|
|
#include "ScreenManager.h"
|
|
#include "ScreenSelectMusic.h"
|
|
#include "ScreenEvaluation.h"
|
|
#include "GameConstantsAndTypes.h"
|
|
#include "PrefsManager.h"
|
|
#include "GameManager.h"
|
|
#include "ScreenEditMenu.h"
|
|
#include "GameConstantsAndTypes.h"
|
|
#include "RageLog.h"
|
|
#include "GameState.h"
|
|
#include "GameState.h"
|
|
|
|
|
|
//
|
|
// Defines specific to GameScreenTitleMenu
|
|
//
|
|
|
|
|
|
const float MAX_SECONDS_CAN_BE_OFF_BY = 0.20f;
|
|
const float GRAY_ARROW_Y = ARROW_SIZE * 1.5;
|
|
|
|
const float DEBUG_X = SCREEN_LEFT + 10;
|
|
const float DEBUG_Y = CENTER_Y-100;
|
|
|
|
const float HELP_X = SCREEN_LEFT + 10;
|
|
const float HELP_Y = CENTER_Y; // top aligned
|
|
|
|
const float INFO_X = SCREEN_RIGHT - 10 ;
|
|
const float INFO_Y = SCREEN_BOTTOM - 10; // bottom aligned
|
|
|
|
const float MENU_WIDTH = 110;
|
|
const float EDIT_X = CENTER_X + 100;
|
|
const float EDIT_GRAY_Y = CENTER_Y - 2.0f * (float)ARROW_SIZE;
|
|
|
|
const float PLAYER_X = EDIT_X;
|
|
const float PLAYER_Y = SCREEN_TOP;
|
|
|
|
const CString HELP_TEXT =
|
|
"Esc: exit\n"
|
|
"S: save changes\n"
|
|
"Up/Down: change beat\n"
|
|
"Left/Right: change snap\n"
|
|
"PgUp/PgDn: jump 1 measure\n"
|
|
"Home/End: jump to first/last beat\n"
|
|
"Number keys: add or remove tap note\n"
|
|
"To create a hold note, hold a number key\n"
|
|
" while changing the beat pressing Up/Down\n"
|
|
"Enter/Space: set begin/end selection markers\n"
|
|
"G/H/J/K/L: Snap selected notes to nearest\n"
|
|
" 4th / 8th / 12th / 16th / 12th or 16th\n"
|
|
"P: Play selected area\n"
|
|
"R: Record in selected area\n"
|
|
"X: Cut selected area\n"
|
|
"C: Copy selected area\n"
|
|
"V: Paste at current beat\n"
|
|
"D: Toggle difficulty\n"
|
|
"Ins: Insert blank beat\n"
|
|
"Del: Delete current beat and shift\n"
|
|
" Hold F keys for faster change:\n"
|
|
"F7/F8: Decrease/increase BPM at cur beat\n"
|
|
"F9/F10: Dec/inc freeze secs at cur beat\n"
|
|
"F11/F12: Decrease/increase music offset\n"
|
|
"F1/F2 : Dec/inc sample music start\n"
|
|
"NumPad -/+: Dec/inc sample music length\n"
|
|
"M: Play sample music\n";
|
|
|
|
|
|
|
|
const ScreenMessage SM_GoToPrevState = ScreenMessage(SM_User+1);
|
|
const ScreenMessage SM_GoToNextState = ScreenMessage(SM_User+2);
|
|
|
|
|
|
ScreenEdit::ScreenEdit()
|
|
{
|
|
LOG->WriteLine( "ScreenEdit::ScreenEdit()" );
|
|
|
|
m_pSong = GAMESTATE->m_pCurSong;
|
|
|
|
m_pNotes = GAMESTATE->m_pCurNotes[PLAYER_1];
|
|
if( m_pNotes == NULL )
|
|
{
|
|
m_pNotes = new Notes;
|
|
// Dro Kulix: If m_pNotes->m_NotesType is not changed here,
|
|
// the edit mode is somehow stuck only being able to edit
|
|
// the first four columns of a (NEW) sequence.
|
|
// I've determined that this is because m_NotesType is
|
|
// initialized in the constructor as
|
|
// NOTES_TYPE_DANCE_SINGLE. For minimal impact, I am
|
|
// changing m_NotesType here, but at some point we
|
|
// may want to consider changing it in the Notes
|
|
// constructor, if another reason to do so pops up...
|
|
|
|
// In ScreenEditMenu, the screen preceding this one,
|
|
// GAMEMAN->m_CurStyle is set to the target game style
|
|
// of the current edit. Naturally, this is where we'll
|
|
// want to extract the NotesType for a (NEW) sequence.
|
|
m_pNotes->m_NotesType = GAMESTATE->GetCurrentStyleDef()->m_NotesType;
|
|
|
|
m_pSong->m_apNotes.Add( m_pNotes );
|
|
}
|
|
|
|
NoteData noteData;
|
|
m_pNotes->GetNoteData( ¬eData );
|
|
|
|
|
|
m_Mode = MODE_EDIT;
|
|
|
|
m_fBeat = 0.0f;
|
|
m_fTrailingBeat = m_fBeat;
|
|
|
|
m_PlayerOptions.m_fArrowScrollSpeed = 1;
|
|
m_PlayerOptions.m_ColorType = PlayerOptions::COLOR_NOTE;
|
|
// m_PlayerOptions.m_bShowMeasureBars = true;
|
|
|
|
m_sprBackground.Load( THEME->GetPathTo( GRAPHIC_EDIT_BACKGROUND ) );
|
|
m_sprBackground.StretchTo( CRect(SCREEN_LEFT,SCREEN_TOP,SCREEN_RIGHT,SCREEN_BOTTOM) );
|
|
|
|
|
|
m_GranularityIndicator.SetXY( EDIT_X, EDIT_GRAY_Y );
|
|
m_GranularityIndicator.Load();
|
|
m_GranularityIndicator.SetZoom( 0.5f );
|
|
|
|
m_GrayArrowRowEdit.SetXY( EDIT_X, EDIT_GRAY_Y );
|
|
m_GrayArrowRowEdit.Load( PLAYER_1, GAMESTATE->GetCurrentStyleDef(), m_PlayerOptions );
|
|
m_GrayArrowRowEdit.SetZoom( 0.5f );
|
|
|
|
m_NoteFieldEdit.SetXY( EDIT_X, EDIT_GRAY_Y );
|
|
m_NoteFieldEdit.SetZoom( 0.5f );
|
|
m_NoteFieldEdit.Load( ¬eData, PLAYER_1, GAMESTATE->GetCurrentStyleDef(), m_PlayerOptions, 10, 12, NoteField::MODE_EDITING );
|
|
|
|
m_rectRecordBack.StretchTo( CRect(SCREEN_LEFT, SCREEN_TOP, SCREEN_RIGHT, SCREEN_BOTTOM) );
|
|
m_rectRecordBack.SetDiffuseColor( D3DXCOLOR(0,0,0,0) );
|
|
|
|
m_GrayArrowRowRecord.SetXY( EDIT_X, EDIT_GRAY_Y );
|
|
m_GrayArrowRowRecord.Load( PLAYER_1, GAMESTATE->GetCurrentStyleDef(), m_PlayerOptions );
|
|
m_GrayArrowRowRecord.SetZoom( 1.0f );
|
|
|
|
m_NoteFieldRecord.SetXY( EDIT_X, EDIT_GRAY_Y );
|
|
m_NoteFieldRecord.SetZoom( 1.0f );
|
|
m_NoteFieldRecord.Load( ¬eData, PLAYER_1, GAMESTATE->GetCurrentStyleDef(), m_PlayerOptions, 2, 5, NoteField::MODE_EDITING );
|
|
|
|
m_Clipboard.m_iNumTracks = m_NoteFieldEdit.m_iNumTracks;
|
|
|
|
m_Player.Load( PLAYER_1, GAMESTATE->GetCurrentStyleDef(), ¬eData, PlayerOptions(), NULL, NULL, 1, 1 );
|
|
m_Player.SetXY( PLAYER_X, PLAYER_Y );
|
|
|
|
m_Fade.SetClosed();
|
|
|
|
m_textInfo.Load( THEME->GetPathTo(FONT_NORMAL) );
|
|
m_textInfo.SetXY( INFO_X, INFO_Y );
|
|
m_textInfo.SetHorizAlign( Actor::align_right );
|
|
m_textInfo.SetVertAlign( Actor::align_top );
|
|
m_textInfo.SetZoom( 0.5f );
|
|
m_textInfo.SetShadowLength( 2 );
|
|
//m_textInfo.SetText(); // set this below every frame
|
|
|
|
m_textHelp.Load( THEME->GetPathTo(FONT_NORMAL) );
|
|
m_textHelp.SetXY( HELP_X, HELP_Y );
|
|
m_textHelp.SetHorizAlign( Actor::align_left );
|
|
m_textHelp.SetZoom( 0.5f );
|
|
m_textHelp.SetShadowLength( 2 );
|
|
m_textHelp.SetText( HELP_TEXT );
|
|
|
|
|
|
m_soundChangeLine.Load( THEME->GetPathTo(SOUND_EDIT_CHANGE_LINE), 10 );
|
|
m_soundChangeSnap.Load( THEME->GetPathTo(SOUND_EDIT_CHANGE_SNAP) );
|
|
m_soundMarker.Load( THEME->GetPathTo(SOUND_EDIT_CHANGE_SNAP) );
|
|
m_soundInvalid.Load( THEME->GetPathTo(SOUND_MENU_INVALID) );
|
|
|
|
|
|
m_soundMusic.Load( m_pSong->GetMusicPath(), true ); // enable accurate sync
|
|
m_soundMusic.SetPlaybackRate( 0.5f );
|
|
|
|
|
|
m_Fade.OpenWipingRight();
|
|
}
|
|
|
|
ScreenEdit::~ScreenEdit()
|
|
{
|
|
LOG->WriteLine( "ScreenEdit::~ScreenEdit()" );
|
|
m_soundMusic.Stop();
|
|
}
|
|
|
|
|
|
void ScreenEdit::Update( float fDeltaTime )
|
|
{
|
|
float fPositionSeconds = m_soundMusic.GetPositionSeconds();
|
|
float fSongBeat, fBPS;
|
|
bool bFreeze;
|
|
m_pSong->GetBeatAndBPSFromElapsedTime( fPositionSeconds, fSongBeat, fBPS, bFreeze );
|
|
|
|
if( m_Mode == MODE_RECORD || m_Mode == MODE_PLAY )
|
|
{
|
|
m_fBeat = fSongBeat;
|
|
|
|
if( m_fBeat > m_NoteFieldEdit.m_fEndMarker )
|
|
{
|
|
if( m_Mode == MODE_RECORD )
|
|
{
|
|
TransitionToEditFromRecord();
|
|
}
|
|
else if( m_Mode == MODE_PLAY )
|
|
{
|
|
m_soundMusic.Stop();
|
|
m_Mode = MODE_EDIT;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_sprBackground.Update( fDeltaTime );
|
|
m_GranularityIndicator.Update( fDeltaTime );
|
|
m_GrayArrowRowEdit.Update( fDeltaTime, m_fBeat );
|
|
m_NoteFieldEdit.Update( fDeltaTime, m_fBeat );
|
|
m_Fade.Update( fDeltaTime );
|
|
m_textHelp.Update( fDeltaTime );
|
|
m_textInfo.Update( fDeltaTime );
|
|
|
|
if( m_Mode == MODE_RECORD || m_Mode == MODE_PLAY )
|
|
{
|
|
m_rectRecordBack.Update( fDeltaTime );
|
|
}
|
|
|
|
if( m_Mode == MODE_RECORD )
|
|
{
|
|
m_GrayArrowRowRecord.Update( fDeltaTime, m_fBeat );
|
|
m_NoteFieldRecord.Update( fDeltaTime, m_fBeat );
|
|
}
|
|
|
|
if( m_Mode == MODE_PLAY )
|
|
{
|
|
m_Player.Update( fDeltaTime, m_fBeat, 0.35f );
|
|
}
|
|
|
|
//LOG->WriteLine( "ScreenEdit::Update(%f)", fDeltaTime );
|
|
Screen::Update( fDeltaTime );
|
|
|
|
|
|
// Update trailing beat
|
|
float fDelta = m_fBeat - m_fTrailingBeat;
|
|
|
|
if( fabsf(fDelta) < 0.01 )
|
|
{
|
|
m_fTrailingBeat = m_fBeat; // snap
|
|
}
|
|
else
|
|
{
|
|
float fSign = fDelta / fabsf(fDelta);
|
|
float fMoveDelta = fSign*fDeltaTime*40;
|
|
if( fabsf(fMoveDelta) > fabsf(fDelta) )
|
|
fMoveDelta = fDelta;
|
|
m_fTrailingBeat += fMoveDelta;
|
|
|
|
if( fabsf(fDelta) > 10 )
|
|
m_fTrailingBeat += fDelta * fDeltaTime*5;
|
|
}
|
|
|
|
|
|
// float fSongBeat, fBPS;
|
|
/// float fPositionSeconds = m_soundMusic.GetPositionSeconds();
|
|
|
|
// fPositionSeconds += 0.08f; // HACK: The assist ticks are playing too late, so make them play a tiny bit earlier
|
|
// m_pSong->GetBeatAndBPSFromElapsedTime( fPositionSeconds, fSongBeat, fBPS );
|
|
// LOG->WriteLine( "fPositionSeconds = %f, fSongBeat = %f, fBPS = %f", fPositionSeconds, fSongBeat, fBPS );
|
|
|
|
|
|
m_NoteFieldEdit.Update( fDeltaTime, m_fTrailingBeat );
|
|
|
|
int iIndexNow = BeatToNoteRowNotRounded( m_fBeat );
|
|
|
|
|
|
CString sNoteType;
|
|
switch( m_GranularityIndicator.GetSnapMode() )
|
|
{
|
|
case NOTE_4TH: sNoteType = "quarter notes"; break;
|
|
case NOTE_8TH: sNoteType = "eighth notes"; break;
|
|
case NOTE_12TH: sNoteType = "triplets"; break;
|
|
case NOTE_16TH: sNoteType = "sixteenth notes"; break;
|
|
default: ASSERT( false );
|
|
}
|
|
|
|
static int iNumTapNotes = 0, iNumHoldNotes = 0;
|
|
static int iCounter = 0;
|
|
|
|
iCounter++;
|
|
if( iCounter % 30 == 0 )
|
|
{
|
|
iNumTapNotes = m_NoteFieldEdit.GetNumTapNotes();
|
|
iNumHoldNotes = m_NoteFieldEdit.GetNumHoldNotes();
|
|
}
|
|
|
|
m_textInfo.SetText( ssprintf(
|
|
"Snap = %s\n"
|
|
"Beat = %.2f\n"
|
|
"Selection = begin: %.2f, end: %.2f\n"
|
|
"Difficulty = %s\n"
|
|
"Description = %s\n"
|
|
"Num notes tap: %d, hold: %d\n"
|
|
"MusicOffsetSeconds: %.2f\n"
|
|
"Preview start: %.2f, length = %.2f\n",
|
|
sNoteType,
|
|
m_fBeat,
|
|
m_NoteFieldEdit.m_fBeginMarker, m_NoteFieldEdit.m_fEndMarker,
|
|
DifficultyClassToString( m_pNotes->m_DifficultyClass ),
|
|
GAMESTATE->m_pCurNotes[PLAYER_1] ? GAMESTATE->m_pCurNotes[PLAYER_1]->m_sDescription : "no description",
|
|
iNumTapNotes, iNumHoldNotes,
|
|
m_pSong->m_fBeat0OffsetInSeconds,
|
|
m_pSong->m_fMusicSampleStartSeconds, m_pSong->m_fMusicSampleLengthSeconds
|
|
) );
|
|
}
|
|
|
|
|
|
void ScreenEdit::DrawPrimitives()
|
|
{
|
|
m_sprBackground.Draw();
|
|
m_GranularityIndicator.Draw();
|
|
m_GrayArrowRowEdit.Draw();
|
|
m_textHelp.Draw();
|
|
m_NoteFieldEdit.Draw();
|
|
m_textInfo.Draw();
|
|
m_Fade.Draw();
|
|
|
|
if( m_Mode == MODE_RECORD || m_Mode == MODE_PLAY )
|
|
{
|
|
m_rectRecordBack.Draw();
|
|
}
|
|
|
|
if( m_Mode == MODE_RECORD )
|
|
{
|
|
m_GrayArrowRowRecord.Draw();
|
|
m_NoteFieldRecord.Draw();
|
|
}
|
|
|
|
if( m_Mode == MODE_PLAY )
|
|
{
|
|
m_Player.Draw();
|
|
}
|
|
|
|
Screen::DrawPrimitives();
|
|
}
|
|
|
|
void ScreenEdit::Input( const DeviceInput& DeviceI, const InputEventType type, const GameInput &GameI, const MenuInput &MenuI, const StyleInput &StyleI )
|
|
{
|
|
//LOG->WriteLine( "ScreenEdit::Input()" );
|
|
|
|
switch( m_Mode )
|
|
{
|
|
case MODE_EDIT: InputEdit( DeviceI, type, GameI, MenuI, StyleI ); break;
|
|
case MODE_RECORD: InputRecord( DeviceI, type, GameI, MenuI, StyleI ); break;
|
|
case MODE_PLAY: InputPlay( DeviceI, type, GameI, MenuI, StyleI ); break;
|
|
}
|
|
}
|
|
|
|
void ScreenEdit::InputEdit( const DeviceInput& DeviceI, const InputEventType type, const GameInput &GameI, const MenuInput &MenuI, const StyleInput &StyleI )
|
|
{
|
|
///////////////////////////
|
|
// handle pad inputs
|
|
///////////////////////////
|
|
|
|
if( DeviceI.device == DEVICE_KEYBOARD )
|
|
{
|
|
switch( DeviceI.button )
|
|
{
|
|
case DIK_1:
|
|
case DIK_2:
|
|
case DIK_3:
|
|
case DIK_4:
|
|
case DIK_5:
|
|
case DIK_6:
|
|
case DIK_7:
|
|
case DIK_8:
|
|
case DIK_9:
|
|
case DIK_0:
|
|
{
|
|
if( type != IET_FIRST_PRESS )
|
|
break; // We only care about first presses
|
|
|
|
int iCol = DeviceI.button - DIK_1;
|
|
const int iNoteIndex = BeatToNoteRow( m_fBeat );
|
|
|
|
if( iCol >= m_NoteFieldEdit.m_iNumTracks ) // this button is not in the range of columns for this StyleDef
|
|
break;
|
|
|
|
// check for to see if the user intended to remove a HoldNote
|
|
bool bRemovedAHoldNote = false;
|
|
for( int i=0; i<m_NoteFieldEdit.m_iNumHoldNotes; i++ ) // for each HoldNote
|
|
{
|
|
HoldNote &hn = m_NoteFieldEdit.m_HoldNotes[i];
|
|
if( iCol == hn.m_iTrack && // the notes correspond
|
|
iNoteIndex >= hn.m_iStartIndex && iNoteIndex <= hn.m_iEndIndex ) // the cursor lies within this HoldNote
|
|
{
|
|
m_NoteFieldEdit.RemoveHoldNote( i );
|
|
bRemovedAHoldNote = true;
|
|
break; // stop iterating over all HoldNotes
|
|
}
|
|
}
|
|
|
|
if( !bRemovedAHoldNote )
|
|
{
|
|
// We didn't remove a HoldNote, so the user wants to add or delete a TapNote
|
|
if( m_NoteFieldEdit.m_TapNotes[iCol][iNoteIndex] == '0' )
|
|
m_NoteFieldEdit.m_TapNotes[iCol][iNoteIndex] = '1';
|
|
else
|
|
m_NoteFieldEdit.m_TapNotes[iCol][iNoteIndex] = '0';
|
|
}
|
|
}
|
|
break;
|
|
case DIK_ESCAPE:
|
|
SCREENMAN->SetNewScreen( new ScreenEditMenu );
|
|
break;
|
|
case DIK_S:
|
|
{
|
|
// copy edit into current Notes
|
|
Song* pSong = GAMESTATE->m_pCurSong;
|
|
Notes* pNotes = GAMESTATE->m_pCurNotes[PLAYER_1];
|
|
|
|
if( pNotes == NULL )
|
|
{
|
|
// allocate a new Notes
|
|
pNotes = new Notes;
|
|
pSong->m_apNotes.Add( pNotes );
|
|
pNotes->m_NotesType = GAMEMAN->GetStyleDefForStyle( GAMESTATE->m_CurStyle )->m_NotesType;
|
|
pNotes->m_sDescription = "Untitled";
|
|
pNotes->m_iMeter = 1;
|
|
}
|
|
|
|
pNotes->SetNoteData( (NoteData*)&m_NoteFieldEdit );
|
|
GAMESTATE->m_pCurSong->SaveToSMFile();
|
|
SOUND->PlayOnceStreamed( THEME->GetPathTo(SOUND_EDIT_SAVE) );
|
|
}
|
|
break;
|
|
case DIK_UP:
|
|
case DIK_DOWN:
|
|
case DIK_PGUP:
|
|
case DIK_PGDN:
|
|
{
|
|
float fBeatsToMove;
|
|
switch( DeviceI.button )
|
|
{
|
|
case DIK_UP:
|
|
case DIK_DOWN:
|
|
fBeatsToMove = NoteTypeToBeat( m_GranularityIndicator.GetSnapMode() );
|
|
if( DeviceI.button == DIK_UP )
|
|
fBeatsToMove *= -1;
|
|
break;
|
|
case DIK_PGUP:
|
|
case DIK_PGDN:
|
|
fBeatsToMove = BEATS_PER_MEASURE;
|
|
if( DeviceI.button == DIK_PGUP )
|
|
fBeatsToMove *= -1;
|
|
}
|
|
|
|
const int iStartIndex = BeatToNoteRow(m_fBeat);
|
|
const int iEndIndex = BeatToNoteRow(m_fBeat + fBeatsToMove);
|
|
|
|
// check to see if they're holding a button
|
|
for( int col=0; col<m_NoteFieldEdit.m_iNumTracks && col<=10; col++ )
|
|
{
|
|
const DeviceInput di(DEVICE_KEYBOARD, DIK_1+col);
|
|
BOOL bIsBeingHeld = INPUTMAN->IsBeingPressed(di);
|
|
|
|
if( bIsBeingHeld )
|
|
{
|
|
// create a new hold note
|
|
HoldNote newHN;
|
|
newHN.m_iTrack = col;
|
|
newHN.m_iStartIndex = min(iStartIndex, iEndIndex);
|
|
newHN.m_iEndIndex = max(iStartIndex, iEndIndex);
|
|
m_NoteFieldEdit.AddHoldNote( newHN );
|
|
}
|
|
}
|
|
|
|
m_fBeat += fBeatsToMove;
|
|
m_fBeat = clamp( m_fBeat, 0, MAX_BEATS-1 );
|
|
m_fBeat = froundf( m_fBeat, NoteTypeToBeat(m_GranularityIndicator.GetSnapMode()) );
|
|
m_soundChangeLine.Play();
|
|
}
|
|
break;
|
|
case DIK_HOME:
|
|
m_fBeat = 0;
|
|
m_soundChangeLine.Play();
|
|
break;
|
|
case DIK_END:
|
|
m_fBeat = m_NoteFieldEdit.GetLastBeat();
|
|
m_soundChangeLine.Play();
|
|
break;
|
|
case DIK_RIGHT:
|
|
m_GranularityIndicator.PrevSnapMode();
|
|
OnSnapModeChange();
|
|
break;
|
|
case DIK_LEFT:
|
|
m_GranularityIndicator.NextSnapMode();
|
|
OnSnapModeChange();
|
|
break;
|
|
case DIK_RETURN:
|
|
if( m_NoteFieldEdit.m_fEndMarker != -1 && m_fBeat > m_NoteFieldEdit.m_fEndMarker )
|
|
{
|
|
// invalid! The begin maker must be placed before the end marker
|
|
m_soundInvalid.Play();
|
|
}
|
|
else
|
|
{
|
|
m_NoteFieldEdit.m_fBeginMarker = m_fBeat;
|
|
m_soundMarker.Play();
|
|
}
|
|
break;
|
|
case DIK_SPACE:
|
|
if( m_NoteFieldEdit.m_fBeginMarker != -1 && m_fBeat < m_NoteFieldEdit.m_fBeginMarker )
|
|
{
|
|
// invalid! The end maker must be placed after the begin marker
|
|
m_soundInvalid.Play();
|
|
}
|
|
else
|
|
{
|
|
m_NoteFieldEdit.m_fEndMarker = m_fBeat;
|
|
m_soundMarker.Play();
|
|
}
|
|
break;
|
|
case DIK_G:
|
|
case DIK_H:
|
|
case DIK_J:
|
|
case DIK_K:
|
|
case DIK_L:
|
|
{
|
|
if( m_NoteFieldEdit.m_fBeginMarker == -1 || m_NoteFieldEdit.m_fEndMarker == -1 )
|
|
{
|
|
m_soundInvalid.Play();
|
|
}
|
|
else
|
|
{
|
|
NoteType noteType1;
|
|
NoteType noteType2;
|
|
switch( DeviceI.button )
|
|
{
|
|
case DIK_G: noteType1 = NOTE_4TH; noteType2 = NOTE_4TH; break;
|
|
case DIK_H: noteType1 = NOTE_8TH; noteType2 = NOTE_8TH; break;
|
|
case DIK_J: noteType1 = NOTE_12TH; noteType2 = NOTE_12TH; break;
|
|
case DIK_K: noteType1 = NOTE_16TH; noteType2 = NOTE_16TH; break;
|
|
case DIK_L: noteType1 = NOTE_12TH; noteType2 = NOTE_16TH; break;
|
|
default: ASSERT( false );
|
|
}
|
|
|
|
m_NoteFieldEdit.SnapToNearestNoteType( noteType1, noteType2, m_NoteFieldEdit.m_fBeginMarker, m_NoteFieldEdit.m_fEndMarker );
|
|
}
|
|
}
|
|
break;
|
|
case DIK_P:
|
|
{
|
|
if( m_NoteFieldEdit.m_fBeginMarker == -1 || m_NoteFieldEdit.m_fEndMarker == -1 )
|
|
{
|
|
m_soundInvalid.Play();
|
|
break;
|
|
}
|
|
|
|
m_fBeat = m_NoteFieldEdit.m_fBeginMarker;
|
|
|
|
m_Mode = MODE_PLAY;
|
|
|
|
m_Player.Load( PLAYER_1, GAMESTATE->GetCurrentStyleDef(), (NoteData*)&m_NoteFieldEdit, PlayerOptions(), NULL, NULL, 1, 1 );
|
|
|
|
m_rectRecordBack.BeginTweening( 0.5f );
|
|
m_rectRecordBack.SetTweenDiffuseColor( D3DXCOLOR(0,0,0,0.5f) );
|
|
|
|
float fElapsedSeconds = max( 0, m_pSong->GetElapsedTimeFromBeat(m_fBeat) );
|
|
m_soundMusic.SetPositionSeconds( fElapsedSeconds );
|
|
m_soundMusic.Play();
|
|
m_soundMusic.SetPlaybackRate( 1.0f );
|
|
}
|
|
break;
|
|
case DIK_R:
|
|
{
|
|
if( m_NoteFieldEdit.m_fBeginMarker == -1 || m_NoteFieldEdit.m_fEndMarker == -1 )
|
|
{
|
|
m_soundInvalid.Play();
|
|
break;
|
|
}
|
|
|
|
m_fBeat = m_NoteFieldEdit.m_fBeginMarker;
|
|
|
|
// initialize m_NoteFieldRecord
|
|
m_NoteFieldRecord.ClearAll();
|
|
m_NoteFieldRecord.m_iNumTracks = m_NoteFieldEdit.m_iNumTracks;
|
|
m_NoteFieldRecord.m_fBeginMarker = m_NoteFieldEdit.m_fBeginMarker;
|
|
m_NoteFieldRecord.m_fEndMarker = m_NoteFieldEdit.m_fEndMarker;
|
|
|
|
|
|
m_Mode = MODE_RECORD;
|
|
m_rectRecordBack.BeginTweening( 0.5f );
|
|
m_rectRecordBack.SetTweenDiffuseColor( D3DXCOLOR(0,0,0,0.5f) );
|
|
|
|
float fElapsedSeconds = max( 0, m_pSong->GetElapsedTimeFromBeat(m_fBeat) );
|
|
m_soundMusic.SetPositionSeconds( fElapsedSeconds );
|
|
m_soundMusic.Play();
|
|
m_soundMusic.SetPlaybackRate( 0.5f );
|
|
}
|
|
break;
|
|
case DIK_INSERT:
|
|
case DIK_DELETE:
|
|
{
|
|
NoteData temp;
|
|
temp.m_iNumTracks = m_NoteFieldEdit.m_iNumTracks;
|
|
int iTakeFromRow;
|
|
int iPasteAtRow;
|
|
switch( DeviceI.button )
|
|
{
|
|
case DIK_INSERT:
|
|
iTakeFromRow = BeatToNoteRow( m_fBeat );
|
|
iPasteAtRow = BeatToNoteRow( m_fBeat+1 );
|
|
break;
|
|
case DIK_DELETE:
|
|
iTakeFromRow = BeatToNoteRow( m_fBeat+1 );
|
|
iPasteAtRow = BeatToNoteRow( m_fBeat );
|
|
break;
|
|
}
|
|
temp.CopyRange( &m_NoteFieldEdit, iTakeFromRow, MAX_TAP_NOTE_ROWS );
|
|
m_NoteFieldEdit.ClearRange( min(iTakeFromRow,iPasteAtRow), MAX_TAP_NOTE_ROWS );
|
|
m_NoteFieldEdit.CopyRange( &temp, 0, MAX_TAP_NOTE_ROWS-iTakeFromRow, iPasteAtRow );
|
|
}
|
|
break;
|
|
case DIK_X:
|
|
if( m_NoteFieldEdit.m_fBeginMarker == -1 || m_NoteFieldEdit.m_fEndMarker == -1 )
|
|
{
|
|
m_soundInvalid.Play();
|
|
}
|
|
else
|
|
{
|
|
int iFirstRow = BeatToNoteRow( m_NoteFieldEdit.m_fBeginMarker );
|
|
int iLastRow = BeatToNoteRow( m_NoteFieldEdit.m_fEndMarker );
|
|
|
|
m_Clipboard.CopyRange( &m_NoteFieldEdit, iFirstRow, iLastRow );
|
|
m_NoteFieldEdit.ClearRange( iFirstRow, iLastRow );
|
|
}
|
|
break;
|
|
case DIK_C:
|
|
if( m_NoteFieldEdit.m_fBeginMarker == -1 || m_NoteFieldEdit.m_fEndMarker == -1 )
|
|
{
|
|
m_soundInvalid.Play();
|
|
}
|
|
else
|
|
{
|
|
int iFirstRow = BeatToNoteRow( m_NoteFieldEdit.m_fBeginMarker );
|
|
int iLastRow = BeatToNoteRow( m_NoteFieldEdit.m_fEndMarker );
|
|
|
|
m_Clipboard.CopyRange( &m_NoteFieldEdit, iFirstRow, iLastRow );
|
|
}
|
|
break;
|
|
case DIK_V:
|
|
{
|
|
int iSrcFirstRow = 0;
|
|
int iSrcLastRow = BeatToNoteRow( m_Clipboard.GetLastBeat() );
|
|
int iDestFirstRow = BeatToNoteRow( m_fBeat );
|
|
|
|
m_NoteFieldEdit.CopyRange( &m_Clipboard, iSrcFirstRow, iSrcLastRow, iDestFirstRow );
|
|
}
|
|
break;
|
|
|
|
case DIK_D:
|
|
{
|
|
DifficultyClass &dc = m_pNotes->m_DifficultyClass;
|
|
dc = DifficultyClass( (dc+1)%NUM_DIFFICULTY_CLASSES );
|
|
}
|
|
break;
|
|
|
|
case DIK_F7:
|
|
case DIK_F8:
|
|
{
|
|
float fBPM = m_pSong->GetBPMAtBeat( m_fBeat );
|
|
float fDeltaBPM;
|
|
switch( DeviceI.button )
|
|
{
|
|
case DIK_F7: fDeltaBPM = - 0.020f; break;
|
|
case DIK_F8: fDeltaBPM = + 0.020f; break;
|
|
default: ASSERT(0);
|
|
}
|
|
switch( type )
|
|
{
|
|
case IET_SLOW_REPEAT: fDeltaBPM *= 10; break;
|
|
case IET_FAST_REPEAT: fDeltaBPM *= 40; break;
|
|
}
|
|
float fNewBPM = fBPM + fDeltaBPM;
|
|
|
|
for( int i=0; i<m_pSong->m_BPMSegments.GetSize(); i++ )
|
|
if( m_pSong->m_BPMSegments[i].m_fStartBeat == m_fBeat )
|
|
break;
|
|
|
|
if( i == m_pSong->m_BPMSegments.GetSize() ) // there is no BPMSegment at the current beat
|
|
{
|
|
// create a new BPMSegment
|
|
m_pSong->AddBPMSegment( BPMSegment(m_fBeat, fNewBPM) );
|
|
}
|
|
else // BPMSegment being modified is m_BPMSegments[i]
|
|
{
|
|
if( i > 0 && fabsf(m_pSong->m_BPMSegments[i-1].m_fBPM - fNewBPM) < 0.025f )
|
|
m_pSong->m_BPMSegments.RemoveAt( i );
|
|
else
|
|
m_pSong->m_BPMSegments[i].m_fBPM = fNewBPM;
|
|
}
|
|
}
|
|
break;
|
|
case DIK_F9:
|
|
case DIK_F10:
|
|
{
|
|
float fFreezeDelta;
|
|
switch( DeviceI.button )
|
|
{
|
|
case DIK_F9: fFreezeDelta = -0.020f; break;
|
|
case DIK_F10: fFreezeDelta = +0.020f; break;
|
|
default: ASSERT(0);
|
|
}
|
|
switch( type )
|
|
{
|
|
case IET_SLOW_REPEAT: fFreezeDelta *= 10; break;
|
|
case IET_FAST_REPEAT: fFreezeDelta *= 40; break;
|
|
}
|
|
|
|
for( int i=0; i<m_pSong->m_StopSegments.GetSize(); i++ )
|
|
{
|
|
if( m_pSong->m_StopSegments[i].m_fStartBeat == m_fBeat )
|
|
break;
|
|
}
|
|
|
|
if( i == m_pSong->m_StopSegments.GetSize() ) // there is no BPMSegment at the current beat
|
|
{
|
|
// create a new StopSegment
|
|
if( fFreezeDelta > 0 )
|
|
m_pSong->AddStopSegment( StopSegment(m_fBeat, fFreezeDelta) );
|
|
}
|
|
else // StopSegment being modified is m_StopSegments[i]
|
|
{
|
|
m_pSong->m_StopSegments[i].m_fStopSeconds += fFreezeDelta;
|
|
if( m_pSong->m_StopSegments[i].m_fStopSeconds <= 0 )
|
|
m_pSong->m_StopSegments.RemoveAt( i );
|
|
}
|
|
}
|
|
break;
|
|
case DIK_F11:
|
|
case DIK_F12:
|
|
{
|
|
float fOffsetDelta;
|
|
switch( DeviceI.button )
|
|
{
|
|
case DIK_F11: fOffsetDelta = -0.020f; break;
|
|
case DIK_F12: fOffsetDelta = +0.020f; break;
|
|
default: ASSERT(0);
|
|
}
|
|
switch( type )
|
|
{
|
|
case IET_SLOW_REPEAT: fOffsetDelta *= 10; break;
|
|
case IET_FAST_REPEAT: fOffsetDelta *= 40; break;
|
|
}
|
|
|
|
m_pSong->m_fBeat0OffsetInSeconds += fOffsetDelta;
|
|
}
|
|
break;
|
|
case DIK_M:
|
|
MUSIC->Load( m_pSong->GetMusicPath() );
|
|
MUSIC->Play( false, m_pSong->m_fMusicSampleStartSeconds, m_pSong->m_fMusicSampleLengthSeconds );
|
|
break;
|
|
case DIK_F1:
|
|
case DIK_F2:
|
|
{
|
|
float fOffsetDelta;
|
|
switch( DeviceI.button )
|
|
{
|
|
case DIK_F1: fOffsetDelta = -0.025f; break;
|
|
case DIK_F2: fOffsetDelta = +0.025f; break;
|
|
default: ASSERT(0);
|
|
}
|
|
switch( type )
|
|
{
|
|
case IET_SLOW_REPEAT: fOffsetDelta *= 10; break;
|
|
case IET_FAST_REPEAT: fOffsetDelta *= 40; break;
|
|
}
|
|
|
|
m_pSong->m_fMusicSampleStartSeconds += fOffsetDelta;
|
|
}
|
|
break;
|
|
case DIK_SUBTRACT:
|
|
case DIK_ADD:
|
|
{
|
|
float fDelta;
|
|
switch( DeviceI.button )
|
|
{
|
|
case DIK_SUBTRACT: fDelta = -0.025f; break;
|
|
case DIK_ADD: fDelta = +0.025f; break;
|
|
default: ASSERT(0);
|
|
}
|
|
switch( type )
|
|
{
|
|
case IET_SLOW_REPEAT: fDelta *= 10; break;
|
|
case IET_FAST_REPEAT: fDelta *= 40; break;
|
|
}
|
|
|
|
m_pSong->m_fMusicSampleLengthSeconds += fDelta;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ScreenEdit::InputRecord( const DeviceInput& DeviceI, const InputEventType type, const GameInput &GameI, const MenuInput &MenuI, const StyleInput &StyleI )
|
|
{
|
|
if( DeviceI.device == DEVICE_KEYBOARD )
|
|
{
|
|
switch( DeviceI.button )
|
|
{
|
|
case DIK_ESCAPE:
|
|
TransitionToEditFromRecord();
|
|
break;
|
|
}
|
|
}
|
|
switch( StyleI.player )
|
|
{
|
|
case PLAYER_1:
|
|
int iCol;
|
|
iCol = StyleI.col;
|
|
|
|
int iNoteIndex;
|
|
iNoteIndex = BeatToNoteRow( m_fBeat );
|
|
|
|
if( type == IET_FIRST_PRESS )
|
|
{
|
|
m_NoteFieldRecord.m_TapNotes[iCol][iNoteIndex] = '1';
|
|
m_NoteFieldRecord.SnapToNearestNoteType( NOTE_12TH, NOTE_16TH, max(0,m_fBeat-1), m_fBeat+1);
|
|
m_GrayArrowRowRecord.Step( iCol );
|
|
}
|
|
else
|
|
{
|
|
const float fHoldEndSeconds = m_soundMusic.GetPositionSeconds();
|
|
const float fHoldStartSeconds = m_soundMusic.GetPositionSeconds() - TIME_BEFORE_SLOW_REPEATS * m_soundMusic.GetPlaybackRate();
|
|
|
|
float fStartBeat, fEndBeat, fThrowAway;
|
|
bool bFreeze;
|
|
m_pSong->GetBeatAndBPSFromElapsedTime( fHoldStartSeconds, fStartBeat, fThrowAway, bFreeze );
|
|
m_pSong->GetBeatAndBPSFromElapsedTime( fHoldEndSeconds, fEndBeat, fThrowAway, bFreeze );
|
|
|
|
const int iStartIndex = BeatToNoteRow(fStartBeat) - 1;
|
|
const int iEndIndex = BeatToNoteRow(fEndBeat);
|
|
|
|
// create a new hold note
|
|
HoldNote newHN;
|
|
newHN.m_iTrack = iCol;
|
|
newHN.m_iStartIndex = iStartIndex;
|
|
newHN.m_iEndIndex = iEndIndex;
|
|
|
|
m_NoteFieldRecord.AddHoldNote( newHN );
|
|
m_NoteFieldRecord.SnapToNearestNoteType( NOTE_12TH, NOTE_16TH, max(0,m_fBeat-2), m_fBeat+2);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ScreenEdit::InputPlay( const DeviceInput& DeviceI, const InputEventType type, const GameInput &GameI, const MenuInput &MenuI, const StyleInput &StyleI )
|
|
{
|
|
if( type != IET_FIRST_PRESS )
|
|
return;
|
|
|
|
if( DeviceI.device == DEVICE_KEYBOARD )
|
|
{
|
|
switch( DeviceI.button )
|
|
{
|
|
case DIK_ESCAPE:
|
|
m_Mode = MODE_EDIT;
|
|
m_soundMusic.Stop();
|
|
|
|
m_fBeat = froundf( m_fBeat, NoteTypeToBeat(m_GranularityIndicator.GetSnapMode()) );
|
|
break;
|
|
}
|
|
}
|
|
|
|
float fSongBeat, fBPS;
|
|
bool bFreeze;
|
|
m_pSong->GetBeatAndBPSFromElapsedTime( m_soundMusic.GetPositionSeconds(), fSongBeat, fBPS, bFreeze );
|
|
const float fMaxBeatDifference = fBPS * PREFSMAN->m_fJudgeWindow / GAMESTATE->m_SongOptions.m_fMusicRate;
|
|
|
|
switch( StyleI.player )
|
|
{
|
|
case PLAYER_1:
|
|
m_Player.HandlePlayerStep( m_fBeat, StyleI.col, fMaxBeatDifference );
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void ScreenEdit::TransitionToEditFromRecord()
|
|
{
|
|
m_Mode = MODE_EDIT;
|
|
m_soundMusic.Stop();
|
|
|
|
int iNoteIndexBegin = BeatToNoteRow( m_NoteFieldEdit.m_fBeginMarker );
|
|
int iNoteIndexEnd = BeatToNoteRow( m_NoteFieldEdit.m_fEndMarker );
|
|
|
|
// delete old TapNotes in the range
|
|
m_NoteFieldEdit.ClearRange( iNoteIndexBegin, iNoteIndexEnd );
|
|
|
|
m_NoteFieldEdit.CopyRange( (NoteData*)&m_NoteFieldRecord, iNoteIndexBegin, iNoteIndexEnd );
|
|
|
|
m_fBeat = froundf( m_fBeat, NoteTypeToBeat(m_GranularityIndicator.GetSnapMode()) );
|
|
}
|
|
|
|
|
|
void ScreenEdit::HandleScreenMessage( const ScreenMessage SM )
|
|
{
|
|
switch( SM )
|
|
{
|
|
case SM_GoToPrevState:
|
|
SCREENMAN->SetNewScreen( new ScreenEditMenu );
|
|
break;
|
|
case SM_GoToNextState:
|
|
SCREENMAN->SetNewScreen( new ScreenEditMenu );
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void ScreenEdit::OnSnapModeChange()
|
|
{
|
|
m_soundChangeSnap.Play();
|
|
|
|
NoteType nt = m_GranularityIndicator.GetSnapMode();
|
|
int iStepIndex = BeatToNoteRow( m_fBeat );
|
|
int iElementsPerNoteType = BeatToNoteRow( NoteTypeToBeat(nt) );
|
|
int iStepIndexHangover = iStepIndex % iElementsPerNoteType;
|
|
m_fBeat -= NoteRowToBeat( iStepIndexHangover );
|
|
}
|