// szNameArray is of size iMax; pNameCache is of size iMax+2.
const RString &EnumToString( int iVal, int iMax, const char **szNameArray, auto_ptr<RString> *pNameCache )
{
if( unlikely(pNameCache[0].get() == NULL) )
{
for( int i = 0; i < iMax; ++i )
{
auto_ptr<RString> ap( new RString( szNameArray[i] ) );
pNameCache[i] = ap;
}
auto_ptr<RString> ap( new RString );
pNameCache[iMax+1] = ap;
}
// iMax+1 is "Invalid". iMax+0 is the NUM_ size value, which can not be converted
// to a string.
// Maybe we should assert on _Invalid? It seems better to make
// the caller check that they're supplying a valid enum value instead of
// returning an inconspicuous garbage value (empty string). -Chris
if (iVal < 0)
FAIL_M(ssprintf("Value %i cannot be negative for enums! Enum hint: %s", iVal, szNameArray[0]));
if (iVal == iMax)
FAIL_M(ssprintf("Value %i cannot be a string with value %i! Enum hint: %s", iVal, iMax, szNameArray[0]));
if (iVal > iMax+1)
FAIL_M(ssprintf("Value %i is past the invalid value %i! Enum hint: %s", iVal, iMax, szNameArray[0]));
return *pNameCache[iVal];
}
void CloseDevice()
{
MMRESULT mRes=0;
if(m_hWaveIn)
{
UnPrepareBuffers();
mRes=waveInClose(m_hWaveIn);
}
if(m_hOPFile)
{
mRes=mmioAscend(m_hOPFile, &m_stckOut, 0);
if(mRes!=MMSYSERR_NOERROR)
{
FAIL_M("bad");
}
mRes=mmioAscend(m_hOPFile, &m_stckOutRIFF, 0);
if(mRes!=MMSYSERR_NOERROR)
{
FAIL_M("bad");
}
mmioClose(m_hOPFile,0);
m_hOPFile=NULL;
}
m_hWaveIn=NULL;
}
bool RageSoundDriver_OSS::GetData()
{
/* Look for a free buffer. */
audio_buf_info ab;
if( ioctl(fd, SNDCTL_DSP_GETOSPACE, &ab) == -1 )
FAIL_M( ssprintf("ioctl(SNDCTL_DSP_GETOSPACE): %s", strerror(errno)) );
if( !ab.fragments )
return false;
const int chunksize = ab.fragsize;
static int16_t *buf = NULL;
if(!buf)
buf = new int16_t[chunksize / sizeof(int16_t)];
this->Mix( buf, chunksize/bytes_per_frame, last_cursor_pos, GetPosition() );
int wrote = write( fd, buf, chunksize );
if( wrote != chunksize )
FAIL_M( ssprintf("write didn't: %i (%s)", wrote, wrote == -1? strerror(errno): "") );
/* Increment last_cursor_pos. */
last_cursor_pos += chunksize / bytes_per_frame;
return true;
}
static void PathForFolderType( char dir[PATH_MAX], OSType folderType )
{
FSRef fs;
if( FSFindFolder(kUserDomain, folderType, kDontCreateFolder, &fs) )
FAIL_M( ssprintf("FSFindFolder(%lu) failed.", folderType) );
if( FSRefMakePath(&fs, (UInt8 *)dir, PATH_MAX) )
FAIL_M( "FSRefMakePath() failed." );
}
static void FixLilEndian()
{
#if defined(ENDIAN_LITTLE)
static bool Initialized = false;
if( Initialized )
return;
Initialized = true;
for( int i = 0; i < AVPixelFormats[i].bpp; ++i )
{
AVPixelFormat_t &pf = AVPixelFormats[i];
if( !pf.bByteSwapOnLittleEndian )
continue;
for( int mask = 0; mask < 4; ++mask)
{
int m = pf.masks[mask];
switch( pf.bpp )
{
case 24: m = Swap24(m); break;
case 32: m = Swap32(m); break;
default:
FAIL_M(ssprintf("Unsupported BPP value: %i", pf.bpp));
}
pf.masks[mask] = m;
}
}
#endif
}
Dialog::Result DialogDriver_MacOSX::AbortRetryIgnore( RString sMessage, RString sID )
{
CFBundleRef bundle = CFBundleGetMainBundle();
CFStringRef sIgnore = LSTRING( bundle, "Ignore" );
CFStringRef sRetry = LSTRING( bundle, "Retry" );
CFStringRef sAbort = LSTRING( bundle, "Abort" );
CFOptionFlags result = ShowAlert( kCFUserNotificationNoteAlertLevel, sMessage, sIgnore, sRetry, sAbort );
CFRelease( sIgnore );
CFRelease( sRetry );
CFRelease( sAbort );
switch( result )
{
case kCFUserNotificationDefaultResponse:
Dialog::IgnoreMessage( sID );
return Dialog::ignore;
case kCFUserNotificationAlternateResponse:
return Dialog::retry;
case kCFUserNotificationOtherResponse:
case kCFUserNotificationCancelResponse:
return Dialog::abort;
default:
FAIL_M( ssprintf("Invalid response: %d.", int(result)) );
}
}
void Alsa9Buf::SetSampleRate(int hz)
{
samplerate = hz;
samplerate_set_explicitly = true;
if( !SetHWParams() )
{
/*
* If this fails, we're no longer set up; if we call SW param calls,
* ALSA will assert out on us (instead of gracefully returning an error).
*
* If we fail here, it means we set up the initial stream, but can't
* configure it to the sample rate we want. This happened on a CS46xx
* with an old ALSA version, at least: snd_pcm_hw_params failed
* with ENOMEM. It set up only 10 44.1khz streams; it may have been
* trying to increase one to 48khz and, for some reason, that needed
* more card memory. (I've tried to work around that by setting up
* streams as 48khz to begin with, so we set it up as the maximum
* to begin with.)
*/
FAIL_M( ssprintf("SetHWParams(%i) failed", hz) );
}
SetSWParams();
}
void HoldJudgment::SetHoldJudgment( HoldNoteScore hns )
{
//LOG->Trace( "Judgment::SetJudgment()" );
// Matt: To save API. Command can handle if desired.
if( hns != HNS_Missed )
{
ResetAnimation();
}
switch( hns )
{
case HNS_Held:
m_sprJudgment->SetState( 0 );
m_sprJudgment->PlayCommand( "Held" );
break;
case HNS_LetGo:
m_sprJudgment->SetState( 1 );
m_sprJudgment->PlayCommand( "LetGo" );
break;
case HNS_Missed:
//m_sprJudgment->SetState( 2 ); // Matt: Not until after 5.0
m_sprJudgment->PlayCommand( "MissedHold" );
break;
case HNS_None:
default:
FAIL_M(ssprintf("Cannot set hold judgment to %i", hns));
}
}
int ScoreKeeperMAX2::TapNoteScoreToGradePoints( TapNoteScore tns, bool bBeginner )
{
if( !GAMESTATE->ShowMarvelous() && tns == TNS_MARVELOUS )
tns = TNS_PERFECT;
/* This is used for Oni percentage displays. Grading values are currently in
* StageStats::GetGrade. */
int iWeight = 0;
switch( tns )
{
case TNS_NONE: iWeight = 0;
case TNS_AVOIDED_MINE: iWeight = 0;
case TNS_HIT_MINE: iWeight = PREFSMAN->m_iGradeWeightHitMine; break;
case TNS_MISS: iWeight = PREFSMAN->m_iGradeWeightMiss; break;
case TNS_BOO: iWeight = PREFSMAN->m_iGradeWeightBoo; break;
case TNS_GOOD: iWeight = PREFSMAN->m_iGradeWeightGood; break;
case TNS_GREAT: iWeight = PREFSMAN->m_iGradeWeightGreat; break;
case TNS_PERFECT: iWeight = PREFSMAN->m_iGradeWeightPerfect; break;
case TNS_MARVELOUS: iWeight = PREFSMAN->m_iGradeWeightMarvelous;break;
default: FAIL_M( ssprintf("%i", tns) );
}
if( bBeginner && PREFSMAN->m_bMercifulBeginner )
iWeight = max( 0, iWeight );
return iWeight;
}
void InputHandler::ButtonPressed( DeviceInput di, bool Down )
{
if( di.ts.IsZero() )
{
di.ts = m_LastUpdate.Half();
++m_iInputsSinceUpdate;
}
INPUTFILTER->ButtonPressed( di, Down );
if( m_iInputsSinceUpdate >= 50 )
{
/*
* We havn't received an update in a long time, so warn about it. We expect to receive
* input events before the first UpdateTimer call only on the first update. Leave
* m_iInputsSinceUpdate where it is, so we only warn once. Only updates that didn't provide
* a timestamp are counted; if the driver provides its own timestamps, UpdateTimer is
* optional.
*
* This can also happen if a device sends a lot of inputs at once; for example, a keyboard
* driver that sends every key in one frame. If that's really needed (wasteful), increase
* the threshold.
*/
LOG->Warn( "InputHandler::ButtonPressed: Driver sent 50 updates without calling UpdateTimer" );
FAIL_M("x");
}
}
Steps *StepsID::ToSteps( const Song *p, bool bAllowNull ) const
{
if( st == StepsType_Invalid || dc == Difficulty_Invalid )
return NULL;
SongID songID;
songID.FromSong( p );
Steps *pRet = NULL;
if( dc == Difficulty_Edit )
{
pRet = SongUtil::GetOneSteps( p, st, dc, -1, -1, sDescription, "", uHash, true );
}
else
{
pRet = SongUtil::GetOneSteps( p, st, dc, -1, -1, "", "", 0, true );
}
if( !bAllowNull && pRet == NULL )
FAIL_M( ssprintf("%i, %i, \"%s\"", st, dc, sDescription.c_str()) );
m_Cache.Set( pRet );
return pRet;
}
void LifeMeterTime::ChangeLife( TapNoteScore tns )
{
if( GetLifeSeconds() <= 0 )
return;
float fMeterChange = 0;
switch( tns )
{
default:
FAIL_M(ssprintf("Invalid TapNoteScore: %i", tns));
case TNS_W1: fMeterChange = g_fTimeMeterSecondsChange[SE_W1]; break;
case TNS_W2: fMeterChange = g_fTimeMeterSecondsChange[SE_W2]; break;
case TNS_W3: fMeterChange = g_fTimeMeterSecondsChange[SE_W3]; break;
case TNS_W4: fMeterChange = g_fTimeMeterSecondsChange[SE_W4]; break;
case TNS_W5: fMeterChange = g_fTimeMeterSecondsChange[SE_W5]; break;
case TNS_Miss: fMeterChange = g_fTimeMeterSecondsChange[SE_Miss]; break;
case TNS_HitMine: fMeterChange = g_fTimeMeterSecondsChange[SE_HitMine]; break;
case TNS_CheckpointHit: fMeterChange = g_fTimeMeterSecondsChange[SE_CheckpointHit]; break;
case TNS_CheckpointMiss:fMeterChange = g_fTimeMeterSecondsChange[SE_CheckpointMiss]; break;
}
float fOldLife = m_fLifeTotalLostSeconds;
m_fLifeTotalLostSeconds -= fMeterChange;
SendLifeChangedMessage( fOldLife, tns, HoldNoteScore_Invalid );
}
void Course::SetCourseType( CourseType ct )
{
if( GetCourseType() == ct )
return;
m_bRepeat = false;
m_iLives = -1;
if( !m_vEntries.empty() )
m_vEntries[0].fGainSeconds = 0;
switch( ct )
{
default:
FAIL_M(ssprintf("Invalid course type: %i", ct));
case COURSE_TYPE_NONSTOP:
break;
case COURSE_TYPE_ONI:
m_iLives = 4;
break;
case COURSE_TYPE_ENDLESS:
m_bRepeat = true;
break;
case COURSE_TYPE_SURVIVAL:
if( !m_vEntries.empty() )
m_vEntries[0].fGainSeconds = 120;
break;
}
}
void ModelManager::UnloadModel( RageModelGeometry *m )
{
m->m_iRefCount--;
ASSERT( m->m_iRefCount >= 0 );
if( m->m_iRefCount )
return; /* Can't unload models that are still referenced. */
for( auto i = m_mapFileToGeometry.begin(); i != m_mapFileToGeometry.end(); ++i )
{
if( i->second == m )
{
if( m_Prefs.m_bDelayedUnload )
{
// leave this geometry loaded
return;
}
else
{
m_mapFileToGeometry.erase( i ); // remove map entry
Rage::safe_delete( m ); // free the texture
return;
}
}
}
FAIL_M("Tried to delete a texture that wasn't loaded");
}
int URLRageFile_open( avcodec::URLContext *h, const char *filename, int flags )
{
if( strncmp( filename, "rage://", 7 ) )
{
LOG->Warn("URLRageFile_open: Unexpected path \"%s\"", filename );
return -EIO;
}
filename += 7;
int mode = 0;
switch( flags )
{
case URL_RDONLY: mode = RageFile::READ; break;
case URL_WRONLY: mode = RageFile::WRITE | RageFile::STREAMED; break;
case URL_RDWR: FAIL_M( "O_RDWR unsupported" );
}
RageFile *f = new RageFile;
if( !f->Open(filename, mode) )
{
LOG->Trace("Error opening \"%s\": %s", filename, f->GetError().c_str() );
delete f;
return -EIO;
}
h->is_streamed = false;
h->priv_data = f;
return 0;
}
void LifeMeterBar::Load( const PlayerState *pPlayerState, PlayerStageStats *pPlayerStageStats )
{
LifeMeter::Load( pPlayerState, pPlayerStageStats );
PlayerNumber pn = pPlayerState->m_PlayerNumber;
DrainType dtype = pPlayerState->m_PlayerOptions.GetStage().m_DrainType;
switch( dtype )
{
case DrainType_Normal:
m_fLifePercentage = INITIAL_VALUE;
break;
/* These types only go down, so they always start at full. */
case DrainType_NoRecover:
case DrainType_SuddenDeath:
m_fLifePercentage = 1.0f; break;
default:
FAIL_M(ssprintf("Invalid DrainType: %i", dtype));
}
// Change life difficulty to really easy if merciful beginner on
m_bMercifulBeginnerInEffect =
GAMESTATE->m_PlayMode == PLAY_MODE_REGULAR &&
GAMESTATE->IsPlayerEnabled( pPlayerState ) &&
GAMESTATE->m_pCurSteps[pn]->GetDifficulty() == Difficulty_Beginner &&
PREFSMAN->m_bMercifulBeginner;
AfterLifeChanged();
}
GameInput Style::StyleInputToGameInput( int iCol, PlayerNumber pn ) const
{
ASSERT_M( pn < NUM_PLAYERS && iCol < MAX_COLS_PER_PLAYER,
ssprintf("P%i C%i", pn, iCol) );
bool bUsingOneSide = m_StyleType != StyleType_OnePlayerTwoSides && m_StyleType != StyleType_TwoPlayersSharedSides;
FOREACH_ENUM( GameController, gc)
{
if( bUsingOneSide && gc != (int) pn )
continue;
int iButtonsPerController = INPUTMAPPER->GetInputScheme()->m_iButtonsPerController;
for( GameButton gb=GAME_BUTTON_NEXT; gb < iButtonsPerController; gb=(GameButton)(gb+1) )
{
int iThisInputCol = m_iInputColumn[gc][gb-GAME_BUTTON_NEXT];
if( iThisInputCol == END_MAPPING )
break;
if( iThisInputCol == iCol )
return GameInput( gc, gb );
}
}
FAIL_M( ssprintf("Invalid column number %i for player %i in the style %s", iCol, pn, GAMESTATE->GetCurrentStyle()->m_szName) );
};
void LowLevelWindow_Win32::BeginConcurrentRendering()
{
if( !wglMakeCurrent( GraphicsWindow::GetHDC(), g_HGLRC_Background ) )
{
LOG->Warn( hr_ssprintf(GetLastError(), "wglMakeCurrent") );
FAIL_M( hr_ssprintf(GetLastError(), "wglMakeCurrent") );
}
}
void ActorFrame::MoveToHead( Actor* pActor )
{
vector<Actor*>::iterator iter = find( m_SubActors.begin(), m_SubActors.end(), pActor );
if( iter == m_SubActors.end() ) // didn't find
FAIL_M("Nonexistent actor");
m_SubActors.erase( iter );
m_SubActors.insert( m_SubActors.begin(), pActor );
}
void LifeMeterBar::ChangeLife( HoldNoteScore score, TapNoteScore tscore )
{
float fDeltaLife=0.f;
DrainType dtype = m_pPlayerState->m_PlayerOptions.GetSong().m_DrainType;
switch( dtype )
{
case DrainType_Normal:
switch( score )
{
case HNS_Held: fDeltaLife = m_fLifePercentChange.GetValue(SE_Held); break;
case HNS_LetGo: fDeltaLife = m_fLifePercentChange.GetValue(SE_LetGo); break;
case HNS_Missed: fDeltaLife = m_fLifePercentChange.GetValue(SE_Missed); break;
default:
FAIL_M(ssprintf("Invalid HoldNoteScore: %i", score));
}
if(PREFSMAN->m_HarshHotLifePenalty && IsHot() && score == HNS_LetGo)
fDeltaLife = -0.10f; // make it take a while to get back to "hot"
break;
case DrainType_NoRecover:
switch( score )
{
case HNS_Held: fDeltaLife = +0.000f; break;
case HNS_LetGo: fDeltaLife = m_fLifePercentChange.GetValue(SE_LetGo); break;
case HNS_Missed: fDeltaLife = +0.000f; break;
default:
FAIL_M(ssprintf("Invalid HoldNoteScore: %i", score));
}
break;
case DrainType_SuddenDeath:
switch( score )
{
case HNS_Held: fDeltaLife = +0; break;
case HNS_LetGo: fDeltaLife = -1.0f; break;
case HNS_Missed: fDeltaLife = +0; break;
default:
FAIL_M(ssprintf("Invalid HoldNoteScore: %i", score));
}
break;
default:
FAIL_M(ssprintf("Invalid DrainType: %i", dtype));
}
ChangeLife( fDeltaLife );
}
void PrepareBuffers()
{
MMRESULT mRes=0;
for(int nT1=0;nT1<MAX_BUFFERS;++nT1)
{
int iSampleCount = SAMPLES_PER_SEC / 60; // 60 times per second
int iBufferSizeBytes = iSampleCount*sizeof(short);
m_stWHDR[nT1].lpData=(LPSTR)HeapAlloc(GetProcessHeap(),8,iBufferSizeBytes);
m_stWHDR[nT1].dwBufferLength=iBufferSizeBytes;
m_stWHDR[nT1].dwUser=nT1;
mRes=waveInPrepareHeader(m_hWaveIn,&m_stWHDR[nT1],sizeof(WAVEHDR));
if(mRes!=0)
FAIL_M("bad");
mRes=waveInAddBuffer(m_hWaveIn,&m_stWHDR[nT1],sizeof(WAVEHDR));
if(mRes!=0)
FAIL_M("bad");
}
}
/* XXX: There's a race on last_cursor_pos here: new data might be written after the
* ioctl returns, incrementing last_cursor_pos. */
int64_t RageSoundDriver_OSS::GetPosition() const
{
ASSERT( fd != -1 );
int delay;
if(ioctl(fd, SNDCTL_DSP_GETODELAY, &delay) == -1)
FAIL_M( ssprintf("RageSoundDriver_OSS: ioctl(SNDCTL_DSP_GETODELAY): %s", strerror(errno)) );
return last_cursor_pos - (delay / bytes_per_frame);
}
/* Get a hold note with the same track and end row as hn. */
int NoteData::GetMatchingHoldNote( const HoldNote &hn ) const
{
for( int i=0; i<GetNumHoldNotes(); i++ ) // for each HoldNote
{
const HoldNote &ret = GetHoldNote(i);
if( ret.iTrack == hn.iTrack && ret.iEndRow == hn.iEndRow )
return i;
}
FAIL_M( ssprintf("%i..%i, %i", hn.iStartRow, hn.iEndRow, hn.iTrack) );
}
void StartRecording()
{
OpenDevice();
m_dp.Init( SAMPLES_PER_SEC );
PrepareBuffers();
MMRESULT mRes=waveInStart(m_hWaveIn);
if(mRes!=0)
FAIL_M("bad");
}
Inventory::Inventory()
{
PlayMode mode = GAMESTATE->m_PlayMode;
switch( mode )
{
case PLAY_MODE_BATTLE:
break;
default:
FAIL_M(ssprintf("Inventory not valid for PlayMode %i", mode));
}
}
LifeMeter *LifeMeter::MakeLifeMeter( LifeType t )
{
switch( t )
{
case LifeType_Bar: return new LifeMeterBar;
case LifeType_Battery: return new LifeMeterBattery;
case LifeType_Time: return new LifeMeterTime;
default:
FAIL_M(ssprintf("Unrecognized LifeMeter type: %i", t));
}
}
Character* CharacterManager::GetDefaultCharacter()
{
for( unsigned i=0; i<m_pCharacters.size(); i++ )
{
if( m_pCharacters[i]->IsDefaultCharacter() )
return m_pCharacters[i];
}
/* We always have the default character. */
FAIL_M("There must be a default character available!");
return NULL;
}
ITween *ITween::CreateFromType( TweenType tt )
{
switch( tt )
{
case TWEEN_LINEAR: return new TweenLinear;
case TWEEN_ACCELERATE: return new TweenAccelerate;
case TWEEN_DECELERATE: return new TweenDecelerate;
case TWEEN_SPRING: return new TweenSpring;
default:
FAIL_M(ssprintf("Invalid TweenType: %i", tt));
}
}
RageSoundReader_Vorbisfile *RageSoundReader_Vorbisfile::Copy() const
{
RageFileBasic *pFile = m_pFile->Copy();
pFile->Seek(0);
RageSoundReader_Vorbisfile *ret = new RageSoundReader_Vorbisfile;
/* If we were able to open the sound in the first place, we expect to
* be able to reopen it. */
if( ret->Open(pFile) != OPEN_OK )
FAIL_M( ssprintf("Copying sound failed: %s", ret->GetError().c_str()) );
return ret;
}
int64_t RageSoundDriver_WaveOut::GetPosition() const
{
MMTIME tm;
tm.wType = TIME_SAMPLES;
MMRESULT ret = waveOutGetPosition( m_hWaveOut, &tm, sizeof(tm) );
if( ret != MMSYSERR_NOERROR )
FAIL_M( wo_ssprintf(ret, "waveOutGetPosition failed") );
return tm.u.sample;
}
