void Spellbook::calculateSpellSlots() {
float yOffset = GUIConstants::TOP + SPELL_OFFSET;
float xOffset = GUIConstants::LEFT + GUIConstants::TEXT_OFFSET / 2.f + SpellSlot::ICON_OFFSET;
for (auto& it : m_core->getData().spellsLearned) {
for (auto& it2 : it.second) {
SpellSlot slot = SpellSlot(it2);
slot.setPosition(sf::Vector2f(xOffset, yOffset));
BitmapText text;
text.setCharacterSize(GUIConstants::CHARACTER_SIZE_M);
text.setColor(COLOR_WHITE);
text.setString(g_textProvider->getText(EnumNames::getSpellIDName(it2)));
text.setPosition(sf::Vector2f(xOffset + SpellSlot::ICON_SIZE + SpellSlot::ICON_OFFSET + MARGIN, yOffset));
BitmapText textDesc;
textDesc.setCharacterSize(GUIConstants::CHARACTER_SIZE_S);
textDesc.setColor(COLOR_LIGHT_GREY);
textDesc.setString(g_textProvider->getCroppedText(
EnumNames::getSpellIDName(it2) + "Desc", GUIConstants::CHARACTER_SIZE_S,
static_cast<int>(WIDTH - (SpellSlot::SIZE + 4 * MARGIN))));
textDesc.setPosition(sf::Vector2f(xOffset + SpellSlot::ICON_SIZE + SpellSlot::ICON_OFFSET + MARGIN, yOffset + GUIConstants::CHARACTER_SIZE_M + 4.f));
std::pair<BitmapText, BitmapText> texts = std::pair<BitmapText, BitmapText>(text, textDesc);
m_typeMap.at(it.first)->push_back(std::pair<SpellSlot, std::pair<BitmapText, BitmapText>>(slot, texts));
yOffset += SpellSlot::SIZE + MARGIN;
}
yOffset = GUIConstants::TOP + SPELL_OFFSET;
}
}
ScreenMusicScroll::ScreenMusicScroll( CString sClassName ) : ScreenAttract( sClassName )
{
vector<Song*> arraySongs;
SONGMAN->GetSongs( arraySongs );
SongUtil::SortSongPointerArrayByTitle( arraySongs );
unsigned i;
for( i=0; i < arraySongs.size(); i++ )
{
BitmapText *bt = new BitmapText;
m_textLines.push_back(bt);
Song* pSong = arraySongs[i];
bt->LoadFromFont( THEME->GetPathToF("ScreenMusicScroll titles") );
bt->SetText( pSong->GetFullDisplayTitle(), pSong->GetFullTranslitTitle() );
bt->SetDiffuse( SONGMAN->GetSongColor(pSong) );
bt->SetZoom( TEXT_ZOOM );
this->AddChild( bt );
}
// for( i=0; i<min(NUM_CREDIT_LINES, MAX_CREDIT_LINES); i++ )
// {
// m_textLines[m_iNumLines].LoadFromFont( THEME->GetPathToF("ScreenMusicScroll titles") );
// m_textLines[m_iNumLines].SetText( CREDIT_LINES[i] );
// m_textLines[m_iNumLines].SetZoom( TEXT_ZOOM );
//
// m_iNumLines++;
// }
for( i=0; i<m_textLines.size(); i++ )
{
m_textLines[i]->SetXY( CENTER_X, SCREEN_BOTTOM + 40 );
m_textLines[i]->BeginTweening( SCROLL_DELAY * i );
m_textLines[i]->BeginTweening( 2.0f*SCROLL_SPEED );
m_textLines[i]->SetXY( CENTER_X, SCREEN_TOP - 40 );
}
this->MoveToTail( &m_In ); // put it in the back so it covers up the stuff we just added
this->MoveToTail( &m_Out ); // put it in the back so it covers up the stuff we just added
this->ClearMessageQueue( SM_BeginFadingOut ); // ignore ScreenAttract's SecsToShow
this->PostScreenMessage( SM_BeginFadingOut, 0.2f * i + 3.0f );
SOUND->PlayOnceFromDir( ANNOUNCER->GetPathTo("music scroll") );
}
WndBag::WndBag(Bag* bag, Listener* listener, Mode mode, const std::string& title)
{
this->listener = listener;
this->mode = mode;
this->title = title;
lastMode = mode;
lastBag = bag;
nCols = PixelDungeon::landscape() ? COLS_L : COLS_P;
nRows = (Belongings::BACKPACK_SIZE + 4 + 1) / nCols + ((Belongings::BACKPACK_SIZE + 4 + 1) % nCols > 0 ? 1 : 0);
int slotsWidth = SLOT_SIZE * nCols + SLOT_MARGIN * (nCols - 1);
int slotsHeight = SLOT_SIZE * nRows + SLOT_MARGIN * (nRows - 1);
BitmapText* txtTitle = PixelScene::createText(title.size() > 0 ? title : bag->Name(), 9);
txtTitle->hardlight(TITLE_COLOR);
txtTitle->measure();
txtTitle->x = (int)(slotsWidth - txtTitle->Width()) / 2;
txtTitle->y = (int)(TITLE_HEIGHT - txtTitle->Height()) / 2;
Group::add(txtTitle);
placeItems(bag);
resize(slotsWidth, slotsHeight + TITLE_HEIGHT);
Belongings* stuff = Dungeon::hero->belongings;
//Bag[] bags = {
// stuff.backpack,
// stuff.getItem(SeedPouch.class),
// stuff.getItem(ScrollHolder.class),
// stuff.getItem(WandHolster.class),
// stuff.getItem(Keyring.class) };
//
//for (Bag b : bags) {
// if (b != null) {
// BagTab tab = new BagTab(b);
// tab.setSize(TAB_WIDTH, tabHeight());
// add(tab);
//
// tab.select(b == bag);
// }
//}
}
void LinkedOptionsMenu::SetChoices( const CStringArray &asChoices )
{
ClearChoices();
for( unsigned i = 0; i < asChoices.size(); i++ )
{
CString ch = asChoices[i];
BitmapText *bt = new BitmapText;
m_Rows.push_back( bt );
bt->LoadFromFont( THEME->GetPathF( m_sName, "menutext" ) );
bt->SetName( "Row" );
bt->SetXY( ROW_OFFSET_X, ROW_OFFSET_Y + (ROW_SPACING_Y * (float)(i % ROWS_PER_PAGE)) );
bt->SetText( ch );
m_Frame.AddChild( bt );
ON_COMMAND( *bt );
}
// show first page of choices
for( unsigned i = 0; i < asChoices.size() && i < (unsigned)ROWS_PER_PAGE; i++ )
{
m_Rows[i]->PlayCommand("TweenOn");
}
m_iCurPage = 0;
if ( asChoices.size() > (unsigned)ROWS_PER_PAGE )
{
m_sprIndicatorDown.PlayCommand("TweenOn");
m_bIndTweenedOn[1] = true;
}
if ( m_Rows.size() > 0 )
{
if ( m_bFocus ) m_Cursor.PlayCommand( "TweenOn" );
m_Cursor.SetXY( CURSOR_OFFSET_X + m_Rows[0]->GetX(), m_Rows[0]->GetY() );
m_Cursor.SetBarWidth( floor(m_Rows[0]->GetZoomedWidth()) );
m_iCurrentSelection = 0;
}
else
{
m_iCurrentSelection = -1;
m_Cursor.PlayCommand( "TweenOff" );
if ( m_bFocus )
SCREENMAN->PostMessageToTopScreen( m_smChangeMenu, 0.0f );
}
}
// begin ScreenTextEntryVisual
void ScreenTextEntryVisual::Init()
{
ROW_START_X.Load( m_sName, "RowStartX" );
ROW_START_Y.Load( m_sName, "RowStartY" );
ROW_END_X.Load( m_sName, "RowEndX" );
ROW_END_Y.Load( m_sName, "RowEndY" );
ScreenTextEntry::Init();
m_sprCursor.Load( THEME->GetPathG(m_sName,"cursor") );
m_sprCursor->SetName( "Cursor" );
LOAD_ALL_COMMANDS( m_sprCursor );
this->AddChild( m_sprCursor );
// Init keyboard
{
BitmapText text;
text.LoadFromFont( THEME->GetPathF(m_sName,"keyboard") );
text.SetName( "Keys" );
ActorUtil::LoadAllCommands( text, m_sName );
text.PlayCommand( "Init" );
FOREACH_KeyboardRow( r )
{
for( int x=0; x<KEYS_PER_ROW; ++x )
{
BitmapText *&pbt = m_ptextKeys[r][x];
pbt = text.Copy();
this->AddChild( pbt );
RString s = g_szKeys[r][x];
if( !s.empty() && r == KEYBOARD_ROW_SPECIAL )
s = THEME->GetString( m_sName, s );
pbt->SetText( s );
}
}
}
m_sndChange.Load( THEME->GetPathS(m_sName,"change"), true );
}
void Spellbook::calculateModifierSlots() {
float yOffset = GUIConstants::TOP + SPELL_OFFSET;
float xOffset = GUIConstants::LEFT + 2 * GUIConstants::TEXT_OFFSET;
float modifierXOffset = 213.f;
float textYOffset = SpellSlot::ICON_SIZE / 2.f - GUIConstants::CHARACTER_SIZE_S / 2.f;
for (auto& it : m_core->getData().modfiersLearned) {
BitmapText text;
text.setCharacterSize(GUIConstants::CHARACTER_SIZE_S);
text.setColor(COLOR_WHITE);
text.setPosition(sf::Vector2f(xOffset, yOffset + textYOffset));
text.setString(g_textProvider->getText(EnumNames::getSpellModifierTypeName(it.first)));
m_modifierTexts.push_back(text);
for (int i = 0; i < it.second; i++) {
SpellModifier modifier;
modifier.level = i + 1;
modifier.type = it.first;
ModifierSlot slot(modifier);
slot.setPosition(sf::Vector2f(modifierXOffset + (i * (ModifierSlot::SIZE + MARGIN)), yOffset));
m_modifierSlots.push_back(slot);
}
yOffset += ModifierSlot::SIZE + 6.f;
}
}
void Game::showFPSText(sf::RenderTarget& target, float frameTimeSeconds) {
sf::View oldView = target.getView();
target.setView(target.getDefaultView());
m_fpsList.push_back(frameTimeSeconds);
if (static_cast<int>(m_fpsList.size()) > FPS_AVERAGE_NR) {
m_fpsList.pop_front();
}
// calc average
float sum = 0.f;
for (float f : m_fpsList) {
sum += f;
}
int fps = static_cast<int>(1.f / (sum / FPS_AVERAGE_NR));
BitmapText fpsText = BitmapText(
"FPS: " + std::to_string(fps));
fpsText.setColor(COLOR_BAD);
fpsText.setPosition(sf::Vector2f(1050.f, 10.f));
fpsText.setCharacterSize(16);
target.draw(fpsText);
target.setView(oldView);
}
void Spellbook::calculateModifierSlots()
{
float yOffset = GUIConstants::TOP + GUIConstants::TEXT_OFFSET + 2 * GUIConstants::CHARACTER_SIZE_M + 2 * MARGIN + 2 * BUTTON_SIZE.y;
float xOffset = GUIConstants::LEFT + GUIConstants::TEXT_OFFSET;
int maxY = 4;
int y = 1;
for (auto& it : m_core->getData().modfiersLearned)
{
BitmapText text;
text.setCharacterSize(GUIConstants::CHARACTER_SIZE_M);
text.setColor(CENDRIC_COLOR_WHITE);
text.setPosition(sf::Vector2f(xOffset, yOffset));
text.setString(g_textProvider->getText(EnumNames::getSpellModifierTypeName(it.first)));
m_modifierTexts.push_back(text);
yOffset += GUIConstants::CHARACTER_SIZE_M * 2;
for (int i = 0; i < it.second; i++)
{
SpellModifier modifier;
modifier.level = i + 1;
modifier.type = it.first;
ModifierSlot slot(modifier);
slot.setPosition(sf::Vector2f(xOffset + (i * (ModifierSlot::SIDE_LENGTH + MARGIN)), yOffset));
m_modifierSlots.push_back(slot);
}
if (y >= maxY)
{
yOffset = GUIConstants::TOP + GUIConstants::TEXT_OFFSET + 2 * GUIConstants::CHARACTER_SIZE_M + 2 * MARGIN + 2 * BUTTON_SIZE.y;
xOffset = GUIConstants::LEFT + WIDTH - (3 * ModifierSlot::SIDE_LENGTH + 2 * MARGIN + GUIConstants::TEXT_OFFSET);
y = 0;
}
else
{
y++;
yOffset += GUIConstants::CHARACTER_SIZE_M + ModifierSlot::SIDE_LENGTH;
}
}
}
void OptionRow::LoadExit()
{
m_RowType = OptionRow::ROW_EXIT;
m_RowDef.name = EXIT_NAME;
m_RowDef.choices.push_back( "" );
BitmapText *bt = new BitmapText;
m_textItems.push_back( bt );
bt->LoadFromFont( THEME->GetPathF(m_sType,"item") );
CString sText = "Exit";
PrepareItemText( sText );
bt->SetText( sText );
bt->RunCommands( ITEMS_ON_COMMAND );
bt->SetShadowLength( 0 );
bt->SetX( ITEMS_LONG_ROW_SHARED_X );
m_Frame.AddChild( bt );
FOREACH_PlayerNumber( p )
m_OptionIcons[p].SetHidden( true );
m_sprBullet.SetHidden( true );
m_textTitle.SetHidden( true );
}
ScreenUnlock::ScreenUnlock( CString sClassName ) : ScreenAttract( sClassName )
{
LOG->Trace("ScreenUnlock::ScreenUnlock()");
unsigned NumUnlocks = NUM_UNLOCKS;
if (UNLOCKMAN->m_SongEntries.size() < NumUnlocks)
NumUnlocks = UNLOCKMAN->m_SongEntries.size();
if (!PREFSMAN->m_bUseUnlockSystem || NumUnlocks == 0)
{
this->HandleScreenMessage( SM_GoToNextScreen );
return;
}
PointsUntilNextUnlock.LoadFromFont( THEME->GetPathToF("Common normal") );
PointsUntilNextUnlock.SetHorizAlign( Actor::align_left );
unsigned i;
CString IconCommand = ICON_COMMAND;
for(i=1; i <= NumUnlocks; i++)
{
// get pertaining UnlockEntry
CString SongTitle = DISPLAYED_SONG(i);
if (USE_UNLOCKS_DAT == 1)
if ((unsigned)i <= UNLOCKMAN->m_SongEntries.size() )
SongTitle = UNLOCKMAN->m_SongEntries[i-1].m_sSongName;
LOG->Trace("UnlockScreen: Searching for %s", SongTitle.c_str());
const UnlockEntry *pSong = UNLOCKMAN->FindLockEntry( SongTitle );
if( pSong == NULL)
{
LOG->Trace("Can't find song %s", SongTitle.c_str());
continue;
}
Sprite* entry = new Sprite;
// new unlock graphic
entry->Load( THEME->GetPathToG(ssprintf("ScreenUnlock %d icon", i)) );
// set graphic location
entry->SetName( ssprintf("Unlock%d",i) );
SET_XY( *entry );
entry->Command(IconCommand);
Unlocks.push_back(entry);
if ( !pSong->IsLocked() )
this->AddChild(Unlocks[Unlocks.size() - 1]);
}
// scrolling text
if (UNLOCK_TEXT_SCROLL != 0)
{
float ScrollingTextX = UNLOCK_TEXT_SCROLL_X;
float ScrollingTextStartY = UNLOCK_TEXT_SCROLL_START_Y;
float ScrollingTextEndY = UNLOCK_TEXT_SCROLL_END_Y;
float ScrollingTextZoom = UNLOCK_TEXT_SCROLL_ZOOM;
float ScrollingTextRows = UNLOCK_TEXT_SCROLL_ROWS;
float MaxWidth = UNLOCK_TEXT_SCROLL_MAX_WIDTH;
float SecondsToScroll = TIME_TO_DISPLAY;
if (SecondsToScroll > 2) SecondsToScroll--;
float SECS_PER_CYCLE = 0;
if (UNLOCK_TEXT_SCROLL != 3)
SECS_PER_CYCLE = (float)SecondsToScroll/(ScrollingTextRows + NumUnlocks);
else
SECS_PER_CYCLE = (float)SecondsToScroll/(ScrollingTextRows * 3 + NumUnlocks + 4);
for(i = 1; i <= NumUnlocks; i++)
{
CString DisplayedSong = DISPLAYED_SONG(i);
if (USE_UNLOCKS_DAT == 1)
if ((unsigned)i <= UNLOCKMAN->m_SongEntries.size() )
DisplayedSong = UNLOCKMAN->m_SongEntries[i-1].m_sSongName;
DisplayedSong.MakeUpper();
const UnlockEntry *pSong = UNLOCKMAN->FindLockEntry(DisplayedSong);
if ( pSong == NULL ) // no such song
continue;
BitmapText* text = new BitmapText;
text->LoadFromFont( THEME->GetPathToF("ScreenUnlock text") );
text->SetHorizAlign( Actor::align_left );
text->SetZoom(ScrollingTextZoom);
if (pSong && pSong->m_pSong != NULL)
{
CString title = pSong->m_pSong->GetDisplayMainTitle();
CString subtitle = pSong->m_pSong->GetDisplaySubTitle();
if( subtitle != "" )
title = title + "\n" + subtitle;
text->SetMaxWidth( MaxWidth );
text->SetText( title );
}
else // song is missing, might be a course
{
Course *crs = SONGMAN->FindCourse( DisplayedSong );
if (crs != NULL)
{
text->SetMaxWidth( MaxWidth );
text->SetText( crs->GetFullDisplayTitle() );
text->Command("Diffuse,0,1,0,1");
}
else // entry isn't a song or course
{
text->SetText( "" );
text->Command("Diffuse,0.5,0,0,1");
}
}
if (pSong != NULL && pSong->m_pSong != NULL)
{
if( pSong->IsLocked() ) // song is locked
{
text->SetText("???");
text->SetZoomX(1);
} else { // song is unlocked, change color
RageColor color = SONGMAN->GetGroupColor(pSong->m_pSong->m_sGroupName);
text->SetGlobalDiffuseColor(color);
}
}
text->SetXY(ScrollingTextX, ScrollingTextStartY);
if (UNLOCK_TEXT_SCROLL == 3 && UNLOCK_TEXT_SCROLL_ROWS + i > NumUnlocks)
{ // special command for last unlocks when extreme-style scrolling is in effect
float TargetRow = -0.5f + i + UNLOCK_TEXT_SCROLL_ROWS - NumUnlocks;
float StopOffPoint = ScrollingTextEndY - TargetRow / UNLOCK_TEXT_SCROLL_ROWS * (ScrollingTextEndY - ScrollingTextStartY);
float FirstCycleTime = (UNLOCK_TEXT_SCROLL_ROWS - TargetRow) * SECS_PER_CYCLE;
float SecondCycleTime = (6 + TargetRow) * SECS_PER_CYCLE - FirstCycleTime;
LOG->Trace("Target Row: %f", TargetRow);
LOG->Trace("command for icon %d: %s", i, ssprintf("diffusealpha,0;sleep,%f;diffusealpha,1;linear,%f;y,%f;linear,%f;y,%f;linear,0.1;diffusealpha,0", SECS_PER_CYCLE * (i - 1), FirstCycleTime, StopOffPoint, SecondCycleTime * 2, ScrollingTextEndY).c_str() );
text->Command( ssprintf("diffusealpha,0;sleep,%f;diffusealpha,1;linear,%f;y,%f;linear,%f;y,%f;linear,0.1;diffusealpha,0", SECS_PER_CYCLE * (i - 1), FirstCycleTime, StopOffPoint, SecondCycleTime, ScrollingTextEndY) );
}
else
text->Command( ssprintf("diffusealpha,0;sleep,%f;diffusealpha,1;linear,%f;y,%f;linear,0.1;diffusealpha,0", SECS_PER_CYCLE * (i - 1), SECS_PER_CYCLE * (ScrollingTextRows), ScrollingTextEndY) );
item.push_back(text);
if (UNLOCK_TEXT_SCROLL >= 2)
{
Sprite* IconCount = new Sprite;
// new unlock graphic
IconCount->Load( THEME->GetPathToG(ssprintf("ScreenUnlock %d icon", i)) );
// set graphic location
IconCount->SetXY( UNLOCK_TEXT_SCROLL_ICON_X, ScrollingTextStartY);
IconCount->SetHeight(UNLOCK_TEXT_SCROLL_ICON_SIZE);
IconCount->SetWidth(UNLOCK_TEXT_SCROLL_ICON_SIZE);
if (UNLOCK_TEXT_SCROLL == 3 && UNLOCK_TEXT_SCROLL_ROWS + i > NumUnlocks)
{
float TargetRow = -0.5f + i + UNLOCK_TEXT_SCROLL_ROWS - NumUnlocks;
float StopOffPoint = ScrollingTextEndY - TargetRow / UNLOCK_TEXT_SCROLL_ROWS * (ScrollingTextEndY - ScrollingTextStartY);
float FirstCycleTime = (UNLOCK_TEXT_SCROLL_ROWS - TargetRow) * SECS_PER_CYCLE;
float SecondCycleTime = (6 + TargetRow) * SECS_PER_CYCLE - FirstCycleTime;
LOG->Trace("Target Row: %f", TargetRow);
LOG->Trace("command for icon %d: %s", i, ssprintf("diffusealpha,0;sleep,%f;diffusealpha,1;linear,%f;y,%f;linear,%f;y,%f;linear,0.1;diffusealpha,0", SECS_PER_CYCLE * (i - 1), FirstCycleTime, StopOffPoint, SecondCycleTime * 2, ScrollingTextEndY).c_str() );
IconCount->Command( ssprintf("diffusealpha,0;sleep,%f;diffusealpha,1;linear,%f;y,%f;linear,%f;y,%f;linear,0.1;diffusealpha,0", SECS_PER_CYCLE * (i - 1), FirstCycleTime, StopOffPoint, SecondCycleTime, ScrollingTextEndY) );
}
else
IconCount->Command( ssprintf("diffusealpha,0;sleep,%f;diffusealpha,1;linear,%f;y,%f;linear,0.1;diffusealpha,0", SECS_PER_CYCLE * (i - 1), SECS_PER_CYCLE * (ScrollingTextRows), ScrollingTextEndY) );
ItemIcons.push_back(IconCount);
LOG->Trace("Added unlock text %d", i);
if (UNLOCK_TEXT_SCROLL == 3)
{
if ( !pSong->IsLocked() )
LastUnlocks.push_back(i);
}
}
}
}
if (UNLOCK_TEXT_SCROLL == 3)
{
float ScrollingTextX = UNLOCK_TEXT_SCROLL_X;
float ScrollingTextStartY = UNLOCK_TEXT_SCROLL_START_Y;
float ScrollingTextEndY = UNLOCK_TEXT_SCROLL_END_Y;
float ScrollingTextRows = UNLOCK_TEXT_SCROLL_ROWS;
float MaxWidth = UNLOCK_TEXT_SCROLL_MAX_WIDTH;
float SecondsToScroll = TIME_TO_DISPLAY - 1;
float SECS_PER_CYCLE = (float)SecondsToScroll/(ScrollingTextRows * 3 + NumUnlocks + 4);
for(i=1; i <= UNLOCK_TEXT_SCROLL_ROWS; i++)
{
if (i > LastUnlocks.size())
continue;
unsigned NextIcon = LastUnlocks[LastUnlocks.size() - i];
CString DisplayedSong = DISPLAYED_SONG(NextIcon);
if (USE_UNLOCKS_DAT == 1)
{
if (NextIcon <= UNLOCKMAN->m_SongEntries.size() )
DisplayedSong = UNLOCKMAN->m_SongEntries[NextIcon-1].m_sSongName;
}
DisplayedSong.MakeUpper();
const UnlockEntry *pSong = UNLOCKMAN->FindLockEntry(DisplayedSong);
if (pSong->m_pSong == NULL)
continue;
BitmapText* NewText = new BitmapText;
NewText->LoadFromFont( THEME->GetPathToF("ScreenUnlock text") );
NewText->SetHorizAlign( Actor::align_left );
CString title = pSong->m_pSong->GetDisplayMainTitle();
CString subtitle = pSong->m_pSong->GetDisplaySubTitle();
if( subtitle != "" )
title = title + "\n" + subtitle;
NewText->SetZoom(UNLOCK_TEXT_SCROLL_ZOOM);
NewText->SetMaxWidth( MaxWidth );
NewText->SetText( title );
RageColor color = SONGMAN->GetGroupColor(pSong->m_pSong->m_sGroupName);
NewText->SetGlobalDiffuseColor(color);
NewText->SetXY(ScrollingTextX, ScrollingTextStartY);
NewText->Command( ssprintf("diffusealpha,0;sleep,%f;diffusealpha,1;linear,%f;y,%f;", SECS_PER_CYCLE * (NumUnlocks + 2 * i - 2), SECS_PER_CYCLE * ((ScrollingTextRows - i) * 2 + 1 ), (ScrollingTextStartY + (ScrollingTextEndY - ScrollingTextStartY) * (ScrollingTextRows - i + 0.5) / ScrollingTextRows )) );
// new unlock graphic
Sprite* NewIcon = new Sprite;
NewIcon->Load( THEME->GetPathToG(ssprintf("ScreenUnlock %d icon", NextIcon)) );
// set graphic location
NewIcon->SetXY( UNLOCK_TEXT_SCROLL_ICON_X, ScrollingTextStartY);
NewIcon->SetHeight(UNLOCK_TEXT_SCROLL_ICON_SIZE);
NewIcon->SetWidth(UNLOCK_TEXT_SCROLL_ICON_SIZE);
NewIcon->Command( ssprintf("diffusealpha,0;sleep,%f;diffusealpha,1;linear,%f;y,%f;", SECS_PER_CYCLE * (NumUnlocks + 2 * i - 2), SECS_PER_CYCLE * ((ScrollingTextRows - i) * 2 + 1 ), (ScrollingTextStartY + (ScrollingTextEndY - ScrollingTextStartY) * (ScrollingTextRows - i + 0.5) / ScrollingTextRows )) );
ItemIcons.push_back(NewIcon);
item.push_back(NewText);
}
}
// NOTE: the following two loops require the iterator to
// be ints because if you decrement an unsigned when it
// equals zero, you get the maximum value of an unsigned,
// which is still greater than 0. By typecasting it as
// an integer, you can achieve -1, which exits the loop.
for(i = item.size() - 1; (int)i >= 0; i--)
this->AddChild(item[i]);
for(i = ItemIcons.size() - 1; (int)i >= 0; i--)
this->AddChild(ItemIcons[i]);
PointsUntilNextUnlock.SetName( "PointsDisplay" );
CString PointDisplay = TYPE_TO_DISPLAY;
if (PointDisplay == "DP" || PointDisplay == "Dance")
{
CString sDP = ssprintf( "%d", (int)UNLOCKMAN->DancePointsUntilNextUnlock() );
PointsUntilNextUnlock.SetText( sDP );
} else if (PointDisplay == "AP" || PointDisplay == "Arcade") {
CString sAP = ssprintf( "%d", (int)UNLOCKMAN->ArcadePointsUntilNextUnlock() );
PointsUntilNextUnlock.SetText( sAP );
} else if (PointDisplay == "SP" || PointDisplay == "Song") {
CString sSP = ssprintf( "%d", (int)UNLOCKMAN->SongPointsUntilNextUnlock() );
PointsUntilNextUnlock.SetText( sSP );
}
PointsUntilNextUnlock.SetZoom( POINTS_ZOOM );
SET_XY( PointsUntilNextUnlock );
this->AddChild( &PointsUntilNextUnlock );
this->ClearMessageQueue( SM_BeginFadingOut ); // ignore ScreenAttract's SecsToShow
this->PostScreenMessage( SM_BeginFadingOut, TIME_TO_DISPLAY );
this->SortByDrawOrder();
}
ScreenCredits::ScreenCredits( CString sName ) : ScreenAttract( sName )
{
vector<Song*> arraySongs;
SONGMAN->GetSongs( arraySongs );
SongUtil::SortSongPointerArrayByTitle( arraySongs );
// FIXME: Redo this screen with a BGA
CString sBackgroundsTransformFunction = ssprintf(
"function(self,offset,itemIndex,numItems) "
" self:x(%f*offset); "
" self:y(%f*offset); "
"end",
(float)BACKGROUNDS_SPACING_X,
(float)BACKGROUNDS_SPACING_Y );
m_ScrollerBackgrounds.SetName( "Backgrounds" );
m_ScrollerBackgrounds.Load3(
BACKGROUNDS_SCROLL_SECONDS_PER_ITEM,
4,
false,
sBackgroundsTransformFunction,
false );
SET_XY( m_ScrollerBackgrounds );
this->AddChild( &m_ScrollerBackgrounds );
m_ScrollerFrames.SetName( "Backgrounds" );
m_ScrollerFrames.Load3(
BACKGROUNDS_SCROLL_SECONDS_PER_ITEM,
4,
false,
sBackgroundsTransformFunction,
false );
SET_XY( m_ScrollerFrames );
this->AddChild( &m_ScrollerFrames );
float fTime = 0;
{
for( int i=0; i<NUM_BACKGROUNDS; i++ )
{
Song* pSong = NULL;
for( int j=0; j<50; j++ )
{
pSong = arraySongs[ rand()%arraySongs.size() ];
if( pSong->HasBackground() )
break;
}
Sprite* pBackground = new Sprite;
pBackground->LoadBG( pSong->HasBackground() ? pSong->GetBackgroundPath() : THEME->GetPathG("Common","fallback background") );
pBackground->ScaleToClipped( BACKGROUNDS_WIDTH, BACKGROUNDS_HEIGHT );
m_ScrollerBackgrounds.AddChild( pBackground );
Sprite* pFrame = new Sprite;
pFrame->Load( THEME->GetPathG("ScreenCredits","background frame") );
m_ScrollerFrames.AddChild( pFrame );
}
float fFirst = -2;
float fLast = NUM_BACKGROUNDS+2;
m_ScrollerBackgrounds.SetCurrentAndDestinationItem( fFirst );
m_ScrollerBackgrounds.SetDestinationItem( fLast );
m_ScrollerFrames.SetCurrentAndDestinationItem( fFirst );
m_ScrollerFrames.SetDestinationItem( fLast );
fTime = max( fTime, BACKGROUNDS_SCROLL_SECONDS_PER_ITEM*(fLast-fFirst) );
}
CString sTextsTransformFunction = ssprintf(
"function(self,offset,itemIndex,numItems) "
" self:x(%f*offset); "
" self:y(%f*offset); "
"end",
(float)TEXTS_SPACING_X,
(float)TEXTS_SPACING_Y );
m_ScrollerTexts.SetName( "Texts" );
m_ScrollerTexts.Load3(
TEXTS_SCROLL_SECONDS_PER_ITEM,
40,
false,
sTextsTransformFunction,
false );
SET_XY( m_ScrollerTexts );
this->AddChild( &m_ScrollerTexts );
{
for( unsigned i=0; i<ARRAYLEN(CREDIT_LINES); i++ )
{
BitmapText* pText = new BitmapText;
pText->LoadFromFont( THEME->GetPathF("ScreenCredits","titles") );
pText->SetText( CREDIT_LINES[i].text );
switch( CREDIT_LINES[i].colorIndex )
{
case 1: pText->SetDiffuse( TEXTS_COLOR_INTRO ); break;
case 2: pText->SetDiffuse( TEXTS_COLOR_HEADER ); break;
case 0: pText->SetDiffuse( TEXTS_COLOR_NORMAL ); break;
default: ASSERT(0);
}
pText->SetZoom( TEXTS_ZOOM );
m_ScrollerTexts.AddChild( pText );
}
float fFirst = -10;
float fLast = ARRAYLEN(CREDIT_LINES)+10;
m_ScrollerTexts.SetCurrentAndDestinationItem( fFirst );
m_ScrollerTexts.SetDestinationItem( fLast );
fTime = max( fTime, TEXTS_SCROLL_SECONDS_PER_ITEM*(fLast-fFirst) );
}
this->SortByDrawOrder();
this->ClearMessageQueue( SM_BeginFadingOut ); // ignore ScreenAttract's SecsToShow
this->PostScreenMessage( SM_BeginFadingOut, fTime );
// this->PostScreenMessage( SM_BeginFadingOut, m_Background.GetLengthSeconds() );
SOUND->PlayOnceFromDir( ANNOUNCER->GetPathTo("credits") );
}
void ScreenDebugOverlay::Init()
{
Screen::Init();
// Init debug mappings
// TODO: Arch-specific?
{
g_Mappings.Clear();
g_Mappings.holdForDebug1 = DeviceInput(DEVICE_KEYBOARD, KEY_F3);
g_Mappings.holdForDebug2.MakeInvalid();
g_Mappings.holdForSlow = DeviceInput(DEVICE_KEYBOARD, KEY_ACCENT);
g_Mappings.holdForFast = DeviceInput(DEVICE_KEYBOARD, KEY_TAB);
/* TODO: Find a better way of indicating which option is which here.
* Maybe we should take a page from ScreenEdit's menus and make
* RowDefs()? */
int i=0;
g_Mappings.gameplayButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_F8);
g_Mappings.gameplayButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_F7);
g_Mappings.gameplayButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_F6);
i=0;
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C1);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C2);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C3);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C4);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C5);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C6);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C7);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C8);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C9);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C0);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Cq);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Cw);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Ce);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Cr);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Ct);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Cy);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Cu);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Ci);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Co);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Cp);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_UP);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_DOWN);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_BACK);
g_Mappings.pageButton[DeviceInput(DEVICE_KEYBOARD, KEY_F5)] = 0;
g_Mappings.pageButton[DeviceInput(DEVICE_KEYBOARD, KEY_F6)] = 1;
g_Mappings.pageButton[DeviceInput(DEVICE_KEYBOARD, KEY_F7)] = 2;
g_Mappings.pageButton[DeviceInput(DEVICE_KEYBOARD, KEY_F8)] = 3;
}
map<RString,int> iNextDebugButton;
int iNextGameplayButton = 0;
FOREACH( IDebugLine*, *g_pvpSubscribers, p )
{
RString sPageName = (*p)->GetPageName();
DeviceInput di;
switch( (*p)->GetType() )
{
case IDebugLine::all_screens:
di = g_Mappings.debugButton[iNextDebugButton[sPageName]++];
break;
case IDebugLine::gameplay_only:
di = g_Mappings.gameplayButton[iNextGameplayButton++];
break;
}
(*p)->m_Button = di;
if( find(m_asPages.begin(), m_asPages.end(), sPageName) == m_asPages.end() )
m_asPages.push_back( sPageName );
}
m_iCurrentPage = 0;
m_bForcedHidden = false;
m_Quad.StretchTo( RectF( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT ) );
m_Quad.SetDiffuse( BACKGROUND_COLOR );
this->AddChild( &m_Quad );
// if you're going to add user commands, make sure to have the overrides
// set after parsing the metrics. -aj
m_textHeader.SetName( "HeaderText" );
m_textHeader.LoadFromFont( THEME->GetPathF("ScreenDebugOverlay", "header") );
LOAD_ALL_COMMANDS_AND_SET_XY_AND_ON_COMMAND( m_textHeader );
m_textHeader.SetText( DEBUG_MENU );
this->AddChild( &m_textHeader );
FOREACH_CONST( RString, m_asPages, s )
{
int iPage = s - m_asPages.begin();
DeviceInput di;
bool b = GetKeyFromMap( g_Mappings.pageButton, iPage, di );
ASSERT( b );
RString sButton = INPUTMAN->GetDeviceSpecificInputString( di );
BitmapText *p = new BitmapText;
p->SetName( "PageText" );
p->LoadFromFont( THEME->GetPathF("ScreenDebugOverlay", "page") );
LOAD_ALL_COMMANDS_AND_ON_COMMAND( p );
// todo: Y value is still hardcoded. -aj
p->SetXY( PAGE_START_X+iPage*PAGE_SPACING_X, SCREEN_TOP+20 );
p->SetText( *s + " (" + sButton + ")" );
m_vptextPages.push_back( p );
this->AddChild( p );
}
float ScreenRanking::SetPage( PageToShow pts )
{
bool bBanner = false;
bool bBannerFrame = false;
bool bShowCategory = false;
bool bShowCourseTitle = false;
bool bShowStepsType = false;
bool bShowBullets = false;
bool bShowNames = false;
bool bShowScores = false;
bool bShowPoints = false;
bool bShowTime = false;
bool bShowDifficulty = false;
bool bShowStepsScore = false;
bool bShowCourseDifficulty = false;
bool bShowCourseScore = false;
switch( pts.type )
{
case PAGE_TYPE_CATEGORY:
bBanner = false;
bBannerFrame = false;
bShowCategory = true;
bShowCourseTitle = false;
bShowStepsType = true;
bShowBullets = true;
bShowNames = true;
bShowScores = true;
bShowPoints = false;
bShowTime = false;
bShowDifficulty = false;
bShowStepsScore = false;
break;
case PAGE_TYPE_TRAIL:
bBanner = true;
bBannerFrame = true;
bShowCategory = false;
bShowCourseTitle = true;
bShowStepsType = true;
bShowBullets = true;
bShowNames = true;
bShowScores = !pts.pCourse->IsOni();
bShowPoints = pts.pCourse->IsOni();
bShowTime = pts.pCourse->IsOni();
bShowDifficulty = false;
bShowStepsScore = false;
break;
case PAGE_TYPE_ALL_STEPS:
bBanner = false;
bBannerFrame = false;
bShowCategory = false;
bShowCourseTitle = false;
bShowStepsType = true;
bShowBullets = false;
bShowNames = false;
bShowScores = false;
bShowPoints = false;
bShowTime = false;
bShowDifficulty = true;
bShowStepsScore = true;
break;
case PAGE_TYPE_ALL_COURSES:
bShowStepsType = true;
bShowCourseScore = true;
bShowCourseDifficulty = true;
break;
default:
ASSERT(0);
}
// Reset
m_Banner.SetHidden( !bBanner );
if( bBanner )
{
m_Banner.Reset();
SET_XY_AND_ON_COMMAND( m_Banner );
}
m_sprBannerFrame.SetHidden( !bBannerFrame );
if( bBannerFrame )
{
m_sprBannerFrame.Reset();
SET_XY_AND_ON_COMMAND( m_sprBannerFrame );
}
m_textCategory.SetHidden( !bShowCategory );
if( bShowCategory )
{
m_textCategory.Reset();
SET_XY_AND_ON_COMMAND( m_textCategory );
}
m_textCourseTitle.SetHidden( !bShowCourseTitle );
if( bShowCourseTitle )
{
m_textCourseTitle.Reset();
SET_XY_AND_ON_COMMAND( m_textCourseTitle );
}
m_textStepsType.SetHidden( !bShowStepsType );
if( bShowStepsType )
{
m_textStepsType.Reset();
SET_XY_AND_ON_COMMAND( m_textStepsType );
}
// UGLY: We have to call AddChild every time we re-load an AutoActor
// because the internal Actor* changes.
if( (Actor*)m_sprPageType )
this->RemoveChild( m_sprPageType );
m_sprPageType.Load( THEME->GetPathG(m_sName, "PageType "+PageTypeToString(pts.type)) );
m_sprPageType->SetName( "PageType" );
this->AddChild( m_sprPageType );
SET_XY_AND_ON_COMMAND( m_sprPageType );
{
for( int l=0; l<NUM_RANKING_LINES; l++ )
{
m_sprBullets[l].SetHidden( !bShowBullets );
if( bShowBullets )
{
m_sprBullets[l].Reset();
m_sprBullets[l].StopAnimating();
m_sprBullets[l].SetState( l );
m_sprBullets[l].SetXY( BULLET_X(l), BULLET_Y(l) );
ON_COMMAND( m_sprBullets[l] );
}
m_textNames[l].SetHidden( !bShowNames );
if( bShowNames )
{
m_textNames[l].Reset();
m_textNames[l].SetXY( NAME_X(l), NAME_Y(l) );
m_textNames[l].SetDiffuse( STEPS_TYPE_COLOR(pts.colorIndex) );
ON_COMMAND( m_textNames[l] );
}
m_textScores[l].SetHidden( !bShowScores );
if( bShowScores )
{
m_textScores[l].Reset();
m_textScores[l].SetXY( SCORE_X(l), SCORE_Y(l) );
m_textScores[l].SetDiffuse( STEPS_TYPE_COLOR(pts.colorIndex) );
ON_COMMAND( m_textScores[l] );
}
m_textPoints[l].SetHidden( !bShowPoints );
if( bShowPoints )
{
m_textPoints[l].Reset();
m_textPoints[l].SetXY( POINTS_X(l), POINTS_Y(l) );
m_textPoints[l].SetDiffuse( STEPS_TYPE_COLOR(pts.colorIndex) );
ON_COMMAND( m_textPoints[l] );
}
m_textTime[l].SetHidden( !bShowTime );
if( bShowTime )
{
m_textTime[l].Reset();
m_textTime[l].SetXY( TIME_X(l), TIME_Y(l) );
m_textTime[l].SetDiffuse( STEPS_TYPE_COLOR(pts.colorIndex) );
ON_COMMAND( m_textTime[l] );
}
}
}
{
for( vector<Difficulty>::iterator dc_iter=m_vDiffsToShow.begin(); dc_iter!=m_vDiffsToShow.end(); dc_iter++ )
{
m_sprDifficulty[*dc_iter]->SetHidden( !bShowDifficulty );
if( bShowDifficulty )
{
m_sprDifficulty[*dc_iter]->Reset();
m_sprDifficulty[*dc_iter]->SetXY( DIFFICULTY_X(*dc_iter), DIFFICULTY_Y );
ON_COMMAND( m_sprDifficulty[*dc_iter] );
}
}
m_ListScoreRowItems.SetHidden( !bShowStepsScore );
if( bShowStepsScore )
{
m_ListScoreRowItems.Reset();
SET_XY_AND_ON_COMMAND( m_ListScoreRowItems );
vector<Actor*> vpActors;
for( unsigned i=0; i<m_vpStepsScoreRowItem.size(); i++ )
vpActors.push_back( m_vpStepsScoreRowItem[i] );
m_ListScoreRowItems.Load( vpActors, SONG_SCORE_ROWS_TO_SHOW, SCREEN_WIDTH, ROW_SPACING_Y, false, SONG_SCORE_SECONDS_PER_ROW, 0, false );
for( unsigned s=0; s<m_vpStepsScoreRowItem.size(); s++ )
{
StepsScoreRowItem *pStepsScoreRowItems = m_vpStepsScoreRowItem[s];
pStepsScoreRowItems->m_sprSongFrame.Reset();
pStepsScoreRowItems->m_sprSongFrame.SetXY( SONG_FRAME_OFFSET_X, SONG_FRAME_OFFSET_Y );
pStepsScoreRowItems->m_sprSongFrame.SetUseZBuffer( true );
ON_COMMAND( pStepsScoreRowItems->m_sprSongFrame );
pStepsScoreRowItems->m_textSongTitle.Reset();
pStepsScoreRowItems->m_textSongTitle.SetXY( SONG_TITLE_OFFSET_X, SONG_TITLE_OFFSET_Y );
pStepsScoreRowItems->m_textSongTitle.SetUseZBuffer( true );
ON_COMMAND( pStepsScoreRowItems->m_textSongTitle );
for( vector<Difficulty>::iterator dc_iter=m_vDiffsToShow.begin(); dc_iter!=m_vDiffsToShow.end(); dc_iter++ )
{
pStepsScoreRowItems->m_textStepsScore[*dc_iter].Reset();
pStepsScoreRowItems->m_textStepsScore[*dc_iter].SetXY( STEPS_SCORE_OFFSET_X(*dc_iter), STEPS_SCORE_OFFSET_Y );
pStepsScoreRowItems->m_textStepsScore[*dc_iter].SetUseZBuffer( true );
pStepsScoreRowItems->m_textStepsScore[*dc_iter].SetDiffuse( STEPS_TYPE_COLOR(pts.colorIndex) );
ON_COMMAND( pStepsScoreRowItems->m_textStepsScore[*dc_iter] );
}
}
}
}
{
FOREACH_ShownCourseDifficulty(d)
{
m_sprCourseDifficulty[d]->SetHidden( !bShowCourseDifficulty );
if( bShowCourseDifficulty )
{
m_sprCourseDifficulty[d]->Reset();
m_sprCourseDifficulty[d]->SetXY( COURSE_DIFFICULTY_X(d), COURSE_DIFFICULTY_Y );
ON_COMMAND( m_sprCourseDifficulty[d] );
}
}
m_ListCourseRowItems.SetHidden( !bShowCourseScore );
if( bShowCourseScore )
{
m_ListCourseRowItems.Reset();
SET_XY_AND_ON_COMMAND( m_ListCourseRowItems );
vector<Actor*> vpActors;
for( unsigned i=0; i<m_vpCourseScoreRowItem.size(); i++ )
vpActors.push_back( m_vpCourseScoreRowItem[i] );
m_ListCourseRowItems.Load( vpActors, SONG_SCORE_ROWS_TO_SHOW, SCREEN_WIDTH, ROW_SPACING_Y, false, SONG_SCORE_SECONDS_PER_ROW, 0, false );
for( unsigned s=0; s<m_vpCourseScoreRowItem.size(); s++ )
{
CourseScoreRowItem *pCourseScoreRowItem = m_vpCourseScoreRowItem[s];
pCourseScoreRowItem->m_sprSongFrame.Reset();
pCourseScoreRowItem->m_sprSongFrame.SetXY( SONG_FRAME_OFFSET_X, SONG_FRAME_OFFSET_Y );
pCourseScoreRowItem->m_sprSongFrame.SetUseZBuffer( true );
ON_COMMAND( pCourseScoreRowItem->m_sprSongFrame );
pCourseScoreRowItem->m_textSongTitle.Reset();
pCourseScoreRowItem->m_textSongTitle.SetXY( SONG_TITLE_OFFSET_X, SONG_TITLE_OFFSET_Y );
pCourseScoreRowItem->m_textSongTitle.SetUseZBuffer( true );
ON_COMMAND( pCourseScoreRowItem->m_textSongTitle );
FOREACH_ShownCourseDifficulty(d)
{
pCourseScoreRowItem->m_textStepsScore[d].Reset();
pCourseScoreRowItem->m_textStepsScore[d].SetXY( COURSE_SCORE_OFFSET_X(d), COURSE_SCORE_OFFSET_Y );
pCourseScoreRowItem->m_textStepsScore[d].SetUseZBuffer( true );
pCourseScoreRowItem->m_textStepsScore[d].SetDiffuse( STEPS_TYPE_COLOR(pts.colorIndex) );
ON_COMMAND( pCourseScoreRowItem->m_textStepsScore[d] );
}
}
}
}
// get ranking feat list
//
// init page
//
switch( pts.type )
{
case PAGE_TYPE_CATEGORY:
{
m_textCategory.SetText( ssprintf("Type %c", 'A'+pts.category) );
m_textStepsType.SetText( GameManager::StepsTypeToThemedString(pts.nt) );
for( int l=0; l<NUM_RANKING_LINES; l++ )
{
HighScoreList& hsl = PROFILEMAN->GetMachineProfile()->GetCategoryHighScoreList(pts.nt,pts.category);
HighScore hs;
bool bRecentHighScore = false;
if( l < (int)hsl.vHighScores.size() )
{
hs = hsl.vHighScores[l];
CString *psName = &hsl.vHighScores[l].sName;
bRecentHighScore = find( GAMESTATE->m_vpsNamesThatWereFilled.begin(), GAMESTATE->m_vpsNamesThatWereFilled.end(), psName ) != GAMESTATE->m_vpsNamesThatWereFilled.end();
}
else
{
hs.sName = NO_SCORE_NAME;
}
m_textNames[l].SetText( hs.GetDisplayName() );
m_textScores[l].SetText( ssprintf("%09i",hs.iScore) );
m_textNames[l].SetDiffuse( STEPS_TYPE_COLOR(pts.colorIndex) );
m_textScores[l].SetDiffuse( STEPS_TYPE_COLOR(pts.colorIndex) );
if( bRecentHighScore )
{
m_textNames[l].SetEffectGlowBlink(0.1f);
m_textScores[l].SetEffectGlowBlink(0.1f);
}
else
{
m_textNames[l].SetEffectNone();
m_textScores[l].SetEffectNone();
}
}
}
return SECONDS_PER_PAGE;
case PAGE_TYPE_TRAIL:
{
m_textCourseTitle.SetText( pts.pCourse->GetFullDisplayTitle() );
m_Banner.LoadFromCourse( pts.pCourse );
m_textStepsType.SetText( GameManager::StepsTypeToThemedString(pts.nt) );
const HighScoreList &hsl = PROFILEMAN->GetMachineProfile()->GetCourseHighScoreList( pts.pCourse, pts.pTrail );
for( int l=0; l<NUM_RANKING_LINES; l++ )
{
HighScore hs;
bool bRecentHighScore = false;
if( l < (int)hsl.vHighScores.size() )
{
hs = hsl.vHighScores[l];
const CString *psName = &hsl.vHighScores[l].sName;
bRecentHighScore = find( GAMESTATE->m_vpsNamesThatWereFilled.begin(), GAMESTATE->m_vpsNamesThatWereFilled.end(), psName ) != GAMESTATE->m_vpsNamesThatWereFilled.end();
}
else
{
hs.sName = NO_SCORE_NAME;
}
m_textNames[l].SetText( hs.GetDisplayName() );
if( pts.pCourse->IsOni() )
{
m_textPoints[l].SetText( ssprintf("%04d",hs.iScore) );
m_textTime[l].SetText( SecondsToMMSSMsMs(hs.fSurviveSeconds) );
m_textScores[l].SetText( "" );
} else {
m_textPoints[l].SetText( "" );
m_textTime[l].SetText( "" );
m_textScores[l].SetText( ssprintf("%09d",hs.iScore) );
}
m_textNames[l].SetDiffuse( STEPS_TYPE_COLOR(pts.colorIndex) );
m_textPoints[l].SetDiffuse( STEPS_TYPE_COLOR(pts.colorIndex) );
m_textTime[l].SetDiffuse( STEPS_TYPE_COLOR(pts.colorIndex) );
m_textScores[l].SetDiffuse( STEPS_TYPE_COLOR(pts.colorIndex) );
if( bRecentHighScore )
{
m_textNames[l].SetEffectGlowBlink(0.1f);
m_textScores[l].SetEffectGlowBlink(0.1f);
}
else
{
m_textNames[l].SetEffectNone();
m_textScores[l].SetEffectNone();
}
}
}
return SECONDS_PER_PAGE;
case PAGE_TYPE_ALL_STEPS:
{
m_textStepsType.SetText( GameManager::StepsTypeToThemedString(pts.nt) );
for( unsigned s=0; s<m_vpStepsScoreRowItem.size(); s++ )
{
StepsScoreRowItem *pStepsScoreRowItem = m_vpStepsScoreRowItem[s];
const Song* pSong = pStepsScoreRowItem->m_pSong;
pStepsScoreRowItem->m_textSongTitle.SetText( pSong->GetFullDisplayTitle() );
for( vector<Difficulty>::iterator dc_iter = m_vDiffsToShow.begin(); dc_iter != m_vDiffsToShow.end(); dc_iter++ )
{
const Steps* pSteps = pSong->GetStepsByDifficulty( pts.nt, *dc_iter, false );
BitmapText* pTextStepsScore = &pStepsScoreRowItem->m_textStepsScore[*dc_iter];
if( pSteps == NULL )
{
pTextStepsScore->SetHidden( true );
}
else
{
HighScoreList &hsl = PROFILEMAN->GetMachineProfile()->GetStepsHighScoreList(pSong,pSteps);
HighScore hs = hsl.GetTopScore();
bool bRecentHighScore = false;
if( !hsl.vHighScores.empty() )
{
hs = hsl.GetTopScore();
const CString *psName = &hsl.GetTopScore().sName;
bRecentHighScore = find( GAMESTATE->m_vpsNamesThatWereFilled.begin(), GAMESTATE->m_vpsNamesThatWereFilled.end(), psName ) != GAMESTATE->m_vpsNamesThatWereFilled.end();
}
else
{
hs.sName = NO_SCORE_NAME;
}
CString s;
s = hs.GetDisplayName() + "\n";
s += ssprintf( "%0*.*f%%", PERCENT_TOTAL_SIZE, PERCENT_DECIMAL_PLACES, hs.fPercentDP*100 );
pTextStepsScore->SetText( s );
}
}
}
}
return m_ListScoreRowItems.GetSecondsForCompleteScrollThrough();
case PAGE_TYPE_ALL_COURSES:
{
m_textStepsType.SetText( GameManager::StepsTypeToThemedString(pts.nt) );
for( unsigned c=0; c<m_vpCourseScoreRowItem.size(); c++ )
{
CourseScoreRowItem *pCourseScoreRowItem = m_vpCourseScoreRowItem[c];
const Course* pCourse = pCourseScoreRowItem->m_pCourse;
pCourseScoreRowItem->m_textSongTitle.SetText( pCourse->GetFullDisplayTitle() );
FOREACH_ShownCourseDifficulty( cd )
{
BitmapText* pTextStepsScore = &pCourseScoreRowItem->m_textStepsScore[cd];
Trail *pTrail = pCourse->GetTrail( pts.nt, cd );
pTextStepsScore->SetHidden( pTrail==NULL );
if( pTrail == NULL )
continue;
const HighScoreList &hsl = PROFILEMAN->GetMachineProfile()->GetCourseHighScoreList( pCourse, pTrail );
HighScore hs;
bool bRecentHighScore = false;
if( !hsl.vHighScores.empty() )
{
hs = hsl.vHighScores[0];
const CString *psName = &hsl.GetTopScore().sName;
bRecentHighScore = find( GAMESTATE->m_vpsNamesThatWereFilled.begin(), GAMESTATE->m_vpsNamesThatWereFilled.end(), psName ) != GAMESTATE->m_vpsNamesThatWereFilled.end();
}
else
{
hs.sName = NO_SCORE_NAME;
}
CString s;
s = hs.GetDisplayName() + "\n";
s += ssprintf( "%0*.*f%%", PERCENT_TOTAL_SIZE, PERCENT_DECIMAL_PLACES, hs.fPercentDP*100 );
pTextStepsScore->SetText( s );
}
}
}
return m_ListCourseRowItems.GetSecondsForCompleteScrollThrough();
default:
ASSERT(0);
return 0;
}
}
void OptionRow::AfterImportOptions()
{
// Make all selections the same if bOneChoiceForAllPlayers
// Hack: we only import active players, so if only player 2 is imported,
// we need to copy p2 to p1, not p1 to p2.
if( m_RowDef.bOneChoiceForAllPlayers )
{
PlayerNumber pnCopyFrom = GAMESTATE->m_MasterPlayerNumber;
if( GAMESTATE->m_MasterPlayerNumber == PLAYER_INVALID )
pnCopyFrom = PLAYER_1;
FOREACH_PlayerNumber( p )
m_vbSelected[p] = m_vbSelected[pnCopyFrom];
}
FOREACH_PlayerNumber( p )
{
switch( m_RowDef.selectType )
{
case SELECT_ONE:
{
/* Make sure the row actually has a selection. */
bool bHasASelection = false;
for( unsigned i=0; i<m_vbSelected[p].size(); i++ )
{
if( m_vbSelected[p][i] )
bHasASelection = true;
}
if( !bHasASelection && !m_vbSelected[p].empty() )
m_vbSelected[p][0] = true;
m_iChoiceInRowWithFocus[p] = GetOneSelection(p, true); // focus on the selection we just set
}
break;
case SELECT_MULTIPLE:
case SELECT_NONE:
m_iChoiceInRowWithFocus[p] = 0;
break;
default:
ASSERT(0);
}
}
// init row icons
FOREACH_HumanPlayer( p )
{
LoadOptionIcon( p, "" );
}
// If the items will go off the edge of the screen, then re-init with the "long row" style.
{
BitmapText bt;
bt.LoadFromFont( THEME->GetPathF(m_sType,"item") );
bt.RunCommands( ITEMS_ON_COMMAND );
float fX = ITEMS_START_X;
for( unsigned c=0; c<m_RowDef.choices.size(); c++ )
{
CString sText = m_RowDef.choices[c];
PrepareItemText( sText );
bt.SetText( sText );
fX += bt.GetZoomedWidth();
if( c != m_RowDef.choices.size()-1 )
fX += ITEMS_GAP_X;
if( fX > ITEMS_END_X )
{
m_RowDef.layoutType = LAYOUT_SHOW_ONE_IN_ROW;
break;
}
}
}
//
// load m_textItems
//
switch( m_RowDef.layoutType )
{
case LAYOUT_SHOW_ONE_IN_ROW:
// init text
FOREACH_HumanPlayer( p )
{
BitmapText *bt = new BitmapText;
m_textItems.push_back( bt );
const int iChoiceInRowWithFocus = m_iChoiceInRowWithFocus[p];
bt->LoadFromFont( THEME->GetPathF(m_sType,"item") );
CString sText = (iChoiceInRowWithFocus==-1) ? "" : m_RowDef.choices[iChoiceInRowWithFocus];
// ugly hack for Speed mods --infamouspat
PrepareItemText( sText );
bt->SetText( sText );
bt->RunCommands( ITEMS_ON_COMMAND );
bt->SetShadowLength( 0 );
if( m_RowDef.bOneChoiceForAllPlayers )
{
bt->SetX( ITEMS_LONG_ROW_SHARED_X );
break; // only initialize one item since it's shared
}
else
{
bt->SetX( ITEMS_LONG_ROW_X.GetValue(p) );
}
}
// init underlines
FOREACH_HumanPlayer( p )
{
OptionsCursor *ul = new OptionsCursor;
m_Underline[p].push_back( ul );
ul->Load( m_sType, OptionsCursor::underline );
ul->Set( p );
int iWidth, iX, iY;
GetWidthXY( p, 0, iWidth, iX, iY );
ul->SetX( float(iX) );
ul->SetWidth( float(iWidth) );
}
break;
case LAYOUT_SHOW_ALL_IN_ROW:
{
float fX = ITEMS_START_X;
for( unsigned c=0; c<m_RowDef.choices.size(); c++ )
{
// init text
BitmapText *bt = new BitmapText;
m_textItems.push_back( bt );
bt->LoadFromFont( THEME->GetPathF(m_sType,"item") );
CString sText = m_RowDef.choices[c];
PrepareItemText( sText );
bt->SetText( sText );
bt->RunCommands( ITEMS_ON_COMMAND );
bt->SetShadowLength( 0 );
// set the X position of each item in the line
float fItemWidth = bt->GetZoomedWidth();
fX += fItemWidth/2;
bt->SetX( fX );
// init underlines
FOREACH_HumanPlayer( p )
{
OptionsCursor *ul = new OptionsCursor;
m_Underline[p].push_back( ul );
ul->Load( m_sType, OptionsCursor::underline );
ul->Set( p );
ul->SetX( fX );
ul->SetWidth( truncf(fItemWidth) );
}
fX += fItemWidth/2 + ITEMS_GAP_X;
}
}
break;
default:
ASSERT(0);
}
for( unsigned c=0; c<m_textItems.size(); c++ )
m_Frame.AddChild( m_textItems[c] );
FOREACH_PlayerNumber( p )
for( unsigned c=0; c<m_Underline[p].size(); c++ )
m_Frame.AddChild( m_Underline[p][c] );
m_textTitle.LoadFromFont( THEME->GetPathF(m_sType,"title") );
CString sTitle = GetRowTitle();
m_textTitle.SetText( sTitle );
m_textTitle.SetX( LABELS_X );
m_textTitle.RunCommands( LABELS_ON_COMMAND );
m_sprBullet.Load( THEME->GetPathG(m_sType,"bullet") );
m_sprBullet.SetX( ARROWS_X );
//
// HACK: Set focus to one item in the row, which is "go down"
//
if( m_bFirstItemGoesDown && m_RowDef.name != "Speed" )
FOREACH_PlayerNumber( p )
m_iChoiceInRowWithFocus[p] = 0;
}
ScreenCredits::ScreenCredits( CString sName ) : ScreenAttract( sName )
{
vector<Song*> arraySongs;
SONGMAN->GetSongs( arraySongs );
SongUtil::SortSongPointerArrayByTitle( arraySongs );
// FIXME: Redo this screen with a BGA
m_ScrollerBackgrounds.SetName( "Backgrounds" );
m_ScrollerBackgrounds.Load(
BACKGROUNDS_SCROLL_SECONDS_PER_ITEM,
4,
RageVector3(0, 0, 0),
RageVector3(0, 0, 0),
RageVector3(BACKGROUNDS_SPACING_X, BACKGROUNDS_SPACING_Y, 0),
RageVector3(0, 0, 0) );
SET_XY( m_ScrollerBackgrounds );
this->AddChild( &m_ScrollerBackgrounds );
m_ScrollerFrames.SetName( "Backgrounds" );
m_ScrollerFrames.Load(
BACKGROUNDS_SCROLL_SECONDS_PER_ITEM,
4,
RageVector3(0, 0, 0),
RageVector3(0, 0, 0),
RageVector3(BACKGROUNDS_SPACING_X, BACKGROUNDS_SPACING_Y, 0),
RageVector3(0, 0, 0) );
SET_XY( m_ScrollerFrames );
this->AddChild( &m_ScrollerFrames );
float fTime = 0;
{
for( int i=0; i<NUM_BACKGROUNDS; i++ )
{
Song* pSong = NULL;
for( int j=0; j<50; j++ )
{
pSong = arraySongs[ rand()%arraySongs.size() ];
if( pSong->HasBackground() )
break;
}
Sprite* pBackground = new Sprite;
pBackground->LoadBG( pSong->HasBackground() ? pSong->GetBackgroundPath() : THEME->GetPathToG("Common fallback background") );
pBackground->ScaleToClipped( BACKGROUNDS_WIDTH, BACKGROUNDS_HEIGHT );
m_ScrollerBackgrounds.AddChild( pBackground );
Sprite* pFrame = new Sprite;
pFrame->Load( THEME->GetPathToG("ScreenCredits background frame") );
m_ScrollerFrames.AddChild( pFrame );
}
const int iFirst = -2, iLast = NUM_BACKGROUNDS+2;
m_ScrollerBackgrounds.SetCurrentAndDestinationItem( iFirst );
m_ScrollerBackgrounds.SetDestinationItem( iLast );
m_ScrollerFrames.SetCurrentAndDestinationItem( iFirst );
m_ScrollerFrames.SetDestinationItem( iLast );
fTime = max( fTime, BACKGROUNDS_SCROLL_SECONDS_PER_ITEM*(iLast-iFirst) );
}
m_ScrollerTexts.SetName( "Texts" );
m_ScrollerTexts.Load(
TEXTS_SCROLL_SECONDS_PER_ITEM,
40,
RageVector3(0, 0, 0),
RageVector3(0, 0, 0),
RageVector3(TEXTS_SPACING_X, TEXTS_SPACING_Y, 0),
RageVector3(0, 0, 0) );
SET_XY( m_ScrollerTexts );
this->AddChild( &m_ScrollerTexts );
{
for( unsigned i=0; i<ARRAYSIZE(CREDIT_LINES); i++ )
{
BitmapText* pText = new BitmapText;
pText->LoadFromFont( THEME->GetPathToF("ScreenCredits titles") );
pText->SetText( CREDIT_LINES[i].text );
switch( CREDIT_LINES[i].colorIndex )
{
case 1: pText->SetDiffuse( TEXTS_COLOR_INTRO ); break;
case 2: pText->SetDiffuse( TEXTS_COLOR_HEADER ); break;
case 0: pText->SetDiffuse( TEXTS_COLOR_NORMAL ); break;
default: ASSERT(0);
}
pText->SetZoom( TEXTS_ZOOM );
m_ScrollerTexts.AddChild( pText );
}
const int iFirst = -10, iLast = ARRAYSIZE(CREDIT_LINES)+10;
m_ScrollerTexts.SetCurrentAndDestinationItem( iFirst );
m_ScrollerTexts.SetDestinationItem( iLast );
fTime = max( fTime, TEXTS_SCROLL_SECONDS_PER_ITEM*(iLast-iFirst) );
}
m_Overlay.LoadFromAniDir( THEME->GetPathToB("ScreenCredits overlay") );
this->AddChild( &m_Overlay );
this->MoveToTail( &m_In ); // put it in the back so it covers up the stuff we just added
this->MoveToTail( &m_Out ); // put it in the back so it covers up the stuff we just added
this->ClearMessageQueue( SM_BeginFadingOut ); // ignore ScreenAttract's SecsToShow
LOG->Trace("XXXXXXXXX %f", fTime);
this->PostScreenMessage( SM_BeginFadingOut, fTime );
// this->PostScreenMessage( SM_BeginFadingOut, m_Background.GetLengthSeconds() );
SOUND->PlayOnceFromDir( ANNOUNCER->GetPathTo("credits") );
}
void MusicWheelItem::LoadFromWheelItemData( WheelItemData* pWID )
{
ASSERT( pWID != NULL );
data = pWID;
/*
// copy all data items
this->m_Type = pWID->m_Type;
this->m_sSectionName = pWID->m_sSectionName;
this->m_pCourse = pWID->m_pCourse;
this->m_pSong = pWID->m_pSong;
this->m_color = pWID->m_color;
this->m_Type = pWID->m_Type; */
// init type specific stuff
switch( pWID->m_Type )
{
case TYPE_SECTION:
case TYPE_COURSE:
case TYPE_SORT:
{
CString sDisplayName, sTranslitName;
BitmapText *bt = NULL;
switch( pWID->m_Type )
{
case TYPE_SECTION:
sDisplayName = SONGMAN->ShortenGroupName(data->m_sSectionName);
bt = &m_textSectionName;
break;
case TYPE_COURSE:
sDisplayName = data->m_pCourse->GetFullDisplayTitle();
sTranslitName = data->m_pCourse->GetFullTranslitTitle();
bt = &m_textCourse;
break;
case TYPE_SORT:
sDisplayName = data->m_sLabel;
bt = &m_textSort;
break;
default:
ASSERT(0);
}
bt->SetZoom( 1 );
bt->SetText( sDisplayName, sTranslitName );
bt->SetDiffuse( data->m_color );
bt->TurnRainbowOff();
const float fSourcePixelWidth = (float)bt->GetUnzoomedWidth();
const float fMaxTextWidth = 200;
if( fSourcePixelWidth > fMaxTextWidth )
bt->SetZoomX( fMaxTextWidth / fSourcePixelWidth );
}
break;
case TYPE_SONG:
{
m_TextBanner.LoadFromSong( data->m_pSong );
m_TextBanner.SetDiffuse( data->m_color );
m_WheelNotifyIcon.SetFlags( data->m_Flags );
RefreshGrades();
}
break;
case TYPE_ROULETTE:
m_textRoulette.SetText( THEME->GetMetric("MusicWheel","Roulette") );
break;
case TYPE_RANDOM:
m_textRoulette.SetText( THEME->GetMetric("MusicWheel","Random") );
break;
case TYPE_PORTAL:
m_textRoulette.SetText( THEME->GetMetric("MusicWheel","Portal") );
break;
default:
ASSERT( 0 ); // invalid type
}
}
void OptionRow::SetExitText( CString sExitText )
{
BitmapText *bt = m_textItems.back();
bt->SetText( sExitText );
}
void ScreenUnlockStatus::Init()
{
ScreenAttract::Init();
unsigned iNumUnlocks = UNLOCKMAN->m_UnlockEntries.size();
if( !PREFSMAN->m_bUseUnlockSystem || iNumUnlocks == 0 )
{
this->PostScreenMessage( SM_GoToNextScreen, 0 );
return;
}
unsigned NumUnlocks = UNLOCKMAN->m_UnlockEntries.size();
PointsUntilNextUnlock.LoadFromFont( THEME->GetPathF("Common","normal") );
PointsUntilNextUnlock.SetHorizAlign( align_left );
apActorCommands IconCommand = ICON_COMMAND;
for( unsigned i=1; i <= NumUnlocks; i++ )
{
// get pertaining UnlockEntry
const UnlockEntry &entry = UNLOCKMAN->m_UnlockEntries[i-1];
const Song *pSong = entry.m_Song.ToSong();
if( pSong == NULL)
continue;
Sprite* pSpr = new Sprite;
// new unlock graphic
pSpr->Load( THEME->GetPathG("ScreenUnlockStatus",ssprintf("%04d icon", i)) );
// set graphic location
pSpr->SetName( ssprintf("Unlock%04d",i) );
LOAD_ALL_COMMANDS_AND_SET_XY( pSpr );
pSpr->RunCommands(IconCommand);
Unlocks.push_back(pSpr);
if ( !entry.IsLocked() )
this->AddChild(Unlocks[Unlocks.size() - 1]);
}
// scrolling text
if (UNLOCK_TEXT_SCROLL != 0)
{
float ScrollingTextX = UNLOCK_TEXT_SCROLL_X;
float ScrollingTextStartY = UNLOCK_TEXT_SCROLL_START_Y;
float ScrollingTextEndY = UNLOCK_TEXT_SCROLL_END_Y;
float ScrollingTextZoom = UNLOCK_TEXT_SCROLL_ZOOM;
float ScrollingTextRows = UNLOCK_TEXT_SCROLL_ROWS;
float MaxWidth = UNLOCK_TEXT_SCROLL_MAX_WIDTH;
float SecondsToScroll = TIME_TO_DISPLAY;
if (SecondsToScroll > 2) SecondsToScroll--;
float SECS_PER_CYCLE = 0;
if (UNLOCK_TEXT_SCROLL != 3)
SECS_PER_CYCLE = (float)SecondsToScroll/(ScrollingTextRows + NumUnlocks);
else
SECS_PER_CYCLE = (float)SecondsToScroll/(ScrollingTextRows * 3 + NumUnlocks + 4);
for(unsigned i = 1; i <= NumUnlocks; i++)
{
const UnlockEntry &entry = UNLOCKMAN->m_UnlockEntries[i-1];
BitmapText* text = new BitmapText;
text->LoadFromFont( THEME->GetPathF("ScreenUnlockStatus","text") );
text->SetHorizAlign( align_left );
text->SetZoom(ScrollingTextZoom);
switch( entry.m_Type )
{
case UnlockRewardType_Song:
{
const Song *pSong = entry.m_Song.ToSong();
ASSERT( pSong != NULL );
RString title = pSong->GetDisplayMainTitle();
RString subtitle = pSong->GetDisplaySubTitle();
if( subtitle != "" )
title = title + "\n" + subtitle;
text->SetMaxWidth( MaxWidth );
text->SetText( title );
}
break;
case UnlockRewardType_Course:
{
const Course *pCourse = entry.m_Course.ToCourse();
ASSERT( pCourse != NULL );
text->SetMaxWidth( MaxWidth );
text->SetText( pCourse->GetDisplayFullTitle() );
text->SetDiffuse( RageColor(0,1,0,1) );
}
break;
default:
text->SetText( "" );
text->SetDiffuse( RageColor(0.5f,0,0,1) );
break;
}
if( entry.IsLocked() )
{
text->SetText("???");
text->SetZoomX(1);
}
else
{
// unlocked. change color
const Song *pSong = entry.m_Song.ToSong();
RageColor color = RageColor(1,1,1,1);
if( pSong )
color = SONGMAN->GetSongGroupColor(pSong->m_sGroupName);
text->SetGlobalDiffuseColor(color);
}
text->SetXY( ScrollingTextX, ScrollingTextStartY );
if (UNLOCK_TEXT_SCROLL == 3 && UNLOCK_TEXT_SCROLL_ROWS + i > NumUnlocks)
{ // special command for last unlocks when scrolling is in effect
float TargetRow = -0.5f + i + UNLOCK_TEXT_SCROLL_ROWS - NumUnlocks;
float StopOffPoint = ScrollingTextEndY - TargetRow / UNLOCK_TEXT_SCROLL_ROWS * (ScrollingTextEndY - ScrollingTextStartY);
float FirstCycleTime = (UNLOCK_TEXT_SCROLL_ROWS - TargetRow) * SECS_PER_CYCLE;
float SecondCycleTime = (6 + TargetRow) * SECS_PER_CYCLE - FirstCycleTime;
//LOG->Trace("Target Row: %f", TargetRow);
//LOG->Trace("command for icon %d: %s", i, ssprintf("diffusealpha,0;sleep,%f;diffusealpha,1;linear,%f;y,%f;linear,%f;y,%f;linear,0.1;diffusealpha,0", SECS_PER_CYCLE * (i - 1), FirstCycleTime, StopOffPoint, SecondCycleTime * 2, ScrollingTextEndY).c_str() );
RString sCommand = ssprintf("diffusealpha,0;sleep,%f;diffusealpha,1;linear,%f;y,%f;linear,%f;y,%f;linear,0.1;diffusealpha,0", SECS_PER_CYCLE * (i - 1), FirstCycleTime, StopOffPoint, SecondCycleTime, ScrollingTextEndY);
text->RunCommands( ActorUtil::ParseActorCommands(sCommand) );
}
else
{
RString sCommand = ssprintf("diffusealpha,0;sleep,%f;diffusealpha,1;linear,%f;y,%f;linear,0.1;diffusealpha,0", SECS_PER_CYCLE * (i - 1), SECS_PER_CYCLE * (ScrollingTextRows), ScrollingTextEndY);
text->RunCommands( ActorUtil::ParseActorCommands(sCommand) );
}
item.push_back(text);
if (UNLOCK_TEXT_SCROLL >= 2)
{
Sprite* IconCount = new Sprite;
// new unlock graphic
IconCount->Load( THEME->GetPathG("ScreenUnlockStatus",ssprintf("%04d icon", i)) );
// set graphic location
IconCount->SetXY( UNLOCK_TEXT_SCROLL_ICON_X, ScrollingTextStartY);
IconCount->SetHeight(UNLOCK_TEXT_SCROLL_ICON_SIZE);
IconCount->SetWidth(UNLOCK_TEXT_SCROLL_ICON_SIZE);
if (UNLOCK_TEXT_SCROLL == 3 && UNLOCK_TEXT_SCROLL_ROWS + i > NumUnlocks)
{
float TargetRow = -0.5f + i + UNLOCK_TEXT_SCROLL_ROWS - NumUnlocks;
float StopOffPoint = ScrollingTextEndY - TargetRow / UNLOCK_TEXT_SCROLL_ROWS * (ScrollingTextEndY - ScrollingTextStartY);
float FirstCycleTime = (UNLOCK_TEXT_SCROLL_ROWS - TargetRow) * SECS_PER_CYCLE;
float SecondCycleTime = (6 + TargetRow) * SECS_PER_CYCLE - FirstCycleTime;
//LOG->Trace("Target Row: %f", TargetRow);
//LOG->Trace("command for icon %d: %s", i, ssprintf("diffusealpha,0;sleep,%f;diffusealpha,1;linear,%f;y,%f;linear,%f;y,%f;linear,0.1;diffusealpha,0", SECS_PER_CYCLE * (i - 1), FirstCycleTime, StopOffPoint, SecondCycleTime * 2, ScrollingTextEndY).c_str() );
RString sCommand = ssprintf("diffusealpha,0;sleep,%f;diffusealpha,1;linear,%f;y,%f;linear,%f;y,%f;linear,0.1;diffusealpha,0", SECS_PER_CYCLE * (i - 1), FirstCycleTime, StopOffPoint, SecondCycleTime, ScrollingTextEndY);
IconCount->RunCommands( ActorUtil::ParseActorCommands(sCommand) );
}
else
{
RString sCommand = ssprintf("diffusealpha,0;sleep,%f;diffusealpha,1;linear,%f;y,%f;linear,0.1;diffusealpha,0", SECS_PER_CYCLE * (i - 1), SECS_PER_CYCLE * (ScrollingTextRows), ScrollingTextEndY);
IconCount->RunCommands( ActorUtil::ParseActorCommands(sCommand) );
}
ItemIcons.push_back(IconCount);
//LOG->Trace("Added unlock text %d", i);
if (UNLOCK_TEXT_SCROLL == 3)
{
if ( !entry.IsLocked() )
LastUnlocks.push_back(i);
}
}
}
}
if (UNLOCK_TEXT_SCROLL == 3)
{
float ScrollingTextX = UNLOCK_TEXT_SCROLL_X;
float ScrollingTextStartY = UNLOCK_TEXT_SCROLL_START_Y;
float ScrollingTextEndY = UNLOCK_TEXT_SCROLL_END_Y;
float ScrollingTextRows = UNLOCK_TEXT_SCROLL_ROWS;
float MaxWidth = UNLOCK_TEXT_SCROLL_MAX_WIDTH;
float SecondsToScroll = TIME_TO_DISPLAY - 1;
float SECS_PER_CYCLE = (float)SecondsToScroll/(ScrollingTextRows * 3 + NumUnlocks + 4);
for(unsigned i=1; i <= UNLOCK_TEXT_SCROLL_ROWS; i++)
{
if (i > LastUnlocks.size())
continue;
unsigned NextIcon = LastUnlocks[LastUnlocks.size() - i];
const UnlockEntry &entry = UNLOCKMAN->m_UnlockEntries[NextIcon-1];
const Song *pSong = entry.m_Song.ToSong();
if( pSong == NULL )
continue;
BitmapText* NewText = new BitmapText;
NewText->LoadFromFont( THEME->GetPathF("ScreenUnlockStatus","text") );
NewText->SetHorizAlign( align_left );
RString title = pSong->GetDisplayMainTitle();
RString subtitle = pSong->GetDisplaySubTitle();
if( subtitle != "" )
title = title + "\n" + subtitle;
NewText->SetZoom(UNLOCK_TEXT_SCROLL_ZOOM);
NewText->SetMaxWidth( MaxWidth );
NewText->SetText( title );
RageColor color = SONGMAN->GetSongGroupColor(pSong->m_sGroupName);
NewText->SetGlobalDiffuseColor(color);
NewText->SetXY(ScrollingTextX, ScrollingTextStartY);
{
RString sCommand = ssprintf("diffusealpha,0;sleep,%f;diffusealpha,1;linear,%f;y,%f;", SECS_PER_CYCLE * (NumUnlocks + 2 * i - 2), SECS_PER_CYCLE * ((ScrollingTextRows - i) * 2 + 1 ), (ScrollingTextStartY + (ScrollingTextEndY - ScrollingTextStartY) * (ScrollingTextRows - i + 0.5) / ScrollingTextRows ));
NewText->RunCommands( ActorUtil::ParseActorCommands(sCommand) );
}
// new unlock graphic
Sprite* NewIcon = new Sprite;
NewIcon->Load( THEME->GetPathG("ScreenUnlockStatus",ssprintf("%04d icon", NextIcon)) );
NewIcon->SetXY( UNLOCK_TEXT_SCROLL_ICON_X, ScrollingTextStartY);
NewIcon->SetHeight(UNLOCK_TEXT_SCROLL_ICON_SIZE);
NewIcon->SetWidth(UNLOCK_TEXT_SCROLL_ICON_SIZE);
{
RString sCommand = ssprintf("diffusealpha,0;sleep,%f;diffusealpha,1;linear,%f;y,%f;", SECS_PER_CYCLE * (NumUnlocks + 2 * i - 2), SECS_PER_CYCLE * ((ScrollingTextRows - i) * 2 + 1 ), (ScrollingTextStartY + (ScrollingTextEndY - ScrollingTextStartY) * (ScrollingTextRows - i + 0.5) / ScrollingTextRows ));
NewIcon->RunCommands( ActorUtil::ParseActorCommands(sCommand) );
}
ItemIcons.push_back(NewIcon);
item.push_back(NewText);
}
}
// NOTE: the following two loops require the iterator to
// be ints because if you decrement an unsigned when it
// equals zero, you get the maximum value of an unsigned,
// which is still greater than 0. By typecasting it as
// an integer, you can achieve -1, which exits the loop.
for(int i = item.size() - 1; (int)i >= 0; i--)
this->AddChild(item[i]);
for(int i = ItemIcons.size() - 1; (int)i >= 0; i--)
this->AddChild(ItemIcons[i]);
PointsUntilNextUnlock.SetName( "PointsDisplay" );
RString PointDisplay = TYPE_TO_DISPLAY;
if (PointDisplay == "DP" || PointDisplay == "Dance")
{
RString sDP = ssprintf( "%d", (int)UNLOCKMAN->PointsUntilNextUnlock(UnlockRequirement_DancePoints) );
PointsUntilNextUnlock.SetText( sDP );
}
else if (PointDisplay == "AP" || PointDisplay == "Arcade")
{
RString sAP = ssprintf( "%d", (int)UNLOCKMAN->PointsUntilNextUnlock(UnlockRequirement_ArcadePoints) );
PointsUntilNextUnlock.SetText( sAP );
}
else if (PointDisplay == "SP" || PointDisplay == "Song")
{
RString sSP = ssprintf( "%d", (int)UNLOCKMAN->PointsUntilNextUnlock(UnlockRequirement_SongPoints) );
PointsUntilNextUnlock.SetText( sSP );
}
PointsUntilNextUnlock.SetZoom( POINTS_ZOOM );
LOAD_ALL_COMMANDS_AND_SET_XY( PointsUntilNextUnlock );
this->AddChild( &PointsUntilNextUnlock );
this->ClearMessageQueue( SM_BeginFadingOut ); // ignore ScreenAttract's SecsToShow
this->PostScreenMessage( SM_BeginFadingOut, TIME_TO_DISPLAY );
}
void ComboGraph::Set( const StageStats &s, const PlayerStageStats &pss )
{
using std::max;
const float fFirstSecond = 0;
const float fLastSecond = s.GetTotalPossibleStepsSeconds();
// Find the largest combo.
int iMaxComboSize = 0;
for( unsigned i = 0; i < pss.m_ComboList.size(); ++i )
iMaxComboSize = max( iMaxComboSize, pss.m_ComboList[i].GetStageCnt() );
for( unsigned i = 0; i < pss.m_ComboList.size(); ++i )
{
const PlayerStageStats::Combo_t &combo = pss.m_ComboList[i];
if( combo.GetStageCnt() < MinComboSizeToShow )
continue; // too small
const bool bIsMax = (combo.GetStageCnt() == iMaxComboSize);
LOG->Trace( "combo %i is %f+%f of %f", i, combo.m_fStartSecond, combo.m_fSizeSeconds, fLastSecond );
Actor *pSprite = bIsMax? m_pMaxCombo->Copy() : m_pNormalCombo->Copy();
const float fStart = Rage::scale( combo.m_fStartSecond, fFirstSecond, fLastSecond, 0.0f, 1.0f );
const float fSize = Rage::scale( combo.m_fSizeSeconds, 0.f, fLastSecond-fFirstSecond, 0.0f, 1.0f );
pSprite->SetCropLeft ( Rage::scale( fSize, 0.0f, 1.0f, 0.5f, 0.0f ) );
pSprite->SetCropRight( Rage::scale( fSize, 0.0f, 1.0f, 0.5f, 0.0f ) );
pSprite->SetCropLeft( fStart );
pSprite->SetCropRight( 1 - (fSize + fStart) );
this->AddChild( pSprite );
}
for( unsigned i = 0; i < pss.m_ComboList.size(); ++i )
{
const PlayerStageStats::Combo_t &combo = pss.m_ComboList[i];
if( combo.GetStageCnt() < MinComboSizeToShow )
continue; // too small
if( !iMaxComboSize )
continue;
const bool bIsMax = (combo.GetStageCnt() == iMaxComboSize);
if( !bIsMax )
continue;
BitmapText *pText = m_pComboNumber->Copy();
const float fStart = Rage::scale( combo.m_fStartSecond, fFirstSecond, fLastSecond, 0.0f, 1.0f );
const float fSize = Rage::scale( combo.m_fSizeSeconds, 0.f, fLastSecond-fFirstSecond, 0.0f, 1.0f );
const float fCenterPercent = fStart + fSize/2;
const float fCenterXPos = Rage::scale( fCenterPercent, 0.0f, 1.0f, -BODY_WIDTH/2.0f, BODY_WIDTH/2.0f );
pText->SetX( fCenterXPos );
pText->SetText( fmt::sprintf("%i",combo.GetStageCnt()) );
this->AddChild( pText );
}
// Hide the templates.
m_pNormalCombo->SetVisible( false );
m_pMaxCombo->SetVisible( false );
m_pComboNumber->SetVisible( false );
}
void ScreenDebugOverlay::Init()
{
Screen::Init();
// Init debug mappings
// TODO: Arch-specific?
{
g_Mappings.Clear();
g_Mappings.holdForDebug1 = DeviceInput(DEVICE_KEYBOARD, KEY_F3);
g_Mappings.holdForDebug2.MakeInvalid();
g_Mappings.holdForSlow = DeviceInput(DEVICE_KEYBOARD, KEY_ACCENT);
g_Mappings.holdForFast = DeviceInput(DEVICE_KEYBOARD, KEY_TAB);
g_Mappings.toggleMute = DeviceInput(DEVICE_KEYBOARD, KEY_PAUSE);
/* TODO: Find a better way of indicating which option is which here.
* Maybe we should take a page from ScreenEdit's menus and make
* RowDefs()? */
int i=0;
g_Mappings.gameplayButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_F8);
g_Mappings.gameplayButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_F7);
g_Mappings.gameplayButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_F6);
i=0;
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C1);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C2);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C3);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C4);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C5);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C6);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C7);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C8);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C9);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_C0);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Cq);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Cw);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Ce);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Cr);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Ct);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Cy);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Cu);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Ci);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Co);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Cp);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Ca);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Cs);
g_Mappings.debugButton[i++] = DeviceInput(DEVICE_KEYBOARD, KEY_Cd);
g_Mappings.pageButton[DeviceInput(DEVICE_KEYBOARD, KEY_F5)] = 0;
g_Mappings.pageButton[DeviceInput(DEVICE_KEYBOARD, KEY_F6)] = 1;
g_Mappings.pageButton[DeviceInput(DEVICE_KEYBOARD, KEY_F7)] = 2;
g_Mappings.pageButton[DeviceInput(DEVICE_KEYBOARD, KEY_F8)] = 3;
}
std::map<std::string,int> iNextDebugButton;
int iNextGameplayButton = 0;
for (auto *p: *g_pvpSubscribers)
{
std::string sPageName = p->GetPageName();
DeviceInput di;
switch( p->GetType() )
{
case IDebugLine::all_screens:
di = g_Mappings.debugButton[iNextDebugButton[sPageName]++];
break;
case IDebugLine::gameplay_only:
di = g_Mappings.gameplayButton[iNextGameplayButton++];
break;
}
p->m_Button = di;
if( find(m_asPages.begin(), m_asPages.end(), sPageName) == m_asPages.end() )
m_asPages.push_back( sPageName );
}
m_iCurrentPage = 0;
m_bForcedHidden = false;
m_Quad.StretchTo( Rage::RectF( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT ) );
m_Quad.SetDiffuse( BACKGROUND_COLOR );
this->AddChild( &m_Quad );
// if you're going to add user commands, make sure to have the overrides
// set after parsing the metrics. -aj
m_textHeader.SetName( "HeaderText" );
m_textHeader.LoadFromFont( THEME->GetPathF("ScreenDebugOverlay", "header") );
LOAD_ALL_COMMANDS_AND_SET_XY_AND_ON_COMMAND( m_textHeader );
m_textHeader.SetText( DEBUG_MENU.GetValue() );
this->AddChild( &m_textHeader );
for (auto s = m_asPages.begin(); s != m_asPages.end(); ++s)
{
int iPage = s - m_asPages.begin();
DeviceInput di;
bool b = GetKeyFromMap( g_Mappings.pageButton, iPage, di );
ASSERT( b );
std::string sButton = INPUTMAN->GetDeviceSpecificInputString( di );
BitmapText *p = new BitmapText;
p->SetName( "PageText" );
p->LoadFromFont( THEME->GetPathF("ScreenDebugOverlay", "page") );
LOAD_ALL_COMMANDS_AND_ON_COMMAND( p );
// todo: Y value is still hardcoded. -aj
p->SetXY( PAGE_START_X+iPage*PAGE_SPACING_X, SCREEN_TOP+20 );
p->SetText( *s + " (" + sButton + ")" );
m_vptextPages.push_back( p );
this->AddChild( p );
}
auto onEachLine = [this](IDebugLine *) {
{
BitmapText *bt = new BitmapText;
bt->SetName( "ButtonText" );
bt->LoadFromFont( THEME->GetPathF("ScreenDebugOverlay", "line") );
bt->SetHorizAlign( align_right );
bt->SetText( "blah" );
LOAD_ALL_COMMANDS_AND_ON_COMMAND( *bt );
m_vptextButton.push_back( bt );
this->AddChild( bt );
}
{
BitmapText *bt = new BitmapText;
bt->SetName( "FunctionText" );
bt->LoadFromFont( THEME->GetPathF("ScreenDebugOverlay", "line") );
bt->SetHorizAlign( align_left );
bt->SetText( "blah" );
LOAD_ALL_COMMANDS_AND_ON_COMMAND( *bt );
m_vptextFunction.push_back( bt );
this->AddChild( bt );
}
};
std::for_each(g_pvpSubscribers->begin(), g_pvpSubscribers->end(), onEachLine);
this->SetVisible( false );
}
void ComboGraph::Load( CString Path, const StageStats &s, PlayerNumber pn )
{
ASSERT( m_SubActors.size() == 0 );
/* Find the largest combo. */
int MaxComboSize = 0;
unsigned i;
for( i = 0; i < s.ComboList[pn].size(); ++i )
MaxComboSize = max( MaxComboSize, s.ComboList[pn][i].GetStageCnt() );
float width = -1;
for( i = 0; i < s.ComboList[pn].size(); ++i )
{
const StageStats::Combo_t &combo = s.ComboList[pn][i];
if( combo.GetStageCnt() < MinComboSizeToShow )
continue; /* too small */
const bool IsMax = (combo.GetStageCnt() == MaxComboSize);
LOG->Trace("combo %i is %f+%f", i, combo.fStartSecond, combo.fSizeSeconds);
Sprite *sprite = new Sprite;
sprite->SetName( "ComboBar" );
const CString path = ssprintf( "%s %s", Path.c_str(), IsMax? "max":"normal" );
sprite->Load( THEME->GetPathToG(path) );
const float start = SCALE( combo.fStartSecond, s.fFirstSecond[pn], s.fLastSecond[pn], 0.0f, 1.0f );
const float size = SCALE( combo.fSizeSeconds, 0, s.fLastSecond[pn]-s.fFirstSecond[pn], 0.0f, 1.0f );
sprite->SetCropLeft ( SCALE( size, 0.0f, 1.0f, 0.5f, 0.0f ) );
sprite->SetCropRight( SCALE( size, 0.0f, 1.0f, 0.5f, 0.0f ) );
sprite->BeginTweening( .5f );
sprite->SetCropLeft( start );
sprite->SetCropRight( 1 - (size + start) );
if( width < 0 )
width = sprite->GetUnzoomedWidth();
m_Sprites.push_back( sprite );
this->AddChild( sprite );
}
for( i = 0; i < s.ComboList[pn].size(); ++i )
{
const StageStats::Combo_t &combo = s.ComboList[pn][i];
if( combo.GetStageCnt() < MinComboSizeToShow )
continue; /* too small */
if( !MaxComboSize )
continue;
const bool IsMax = (combo.GetStageCnt() == MaxComboSize);
if( !IsMax )
continue;
BitmapText *text = new BitmapText;
text->SetName( "ComboMaxNumber" );
text->LoadFromFont( THEME->GetPathToF(Path) );
const float start = SCALE( combo.fStartSecond, s.fFirstSecond[pn], s.fLastSecond[pn], 0.0f, 1.0f );
const float size = SCALE( combo.fSizeSeconds, 0, s.fLastSecond[pn]-s.fFirstSecond[pn], 0.0f, 1.0f );
const float CenterPercent = start + size/2;
const float CenterXPos = SCALE( CenterPercent, 0.0f, 1.0f, -width/2.0f, width/2.0f );
text->SetX( CenterXPos );
text->SetText( ssprintf("%i",combo.GetStageCnt()) );
ON_COMMAND( text );
m_Numbers.push_back( text );
this->AddChild( text );
}
}
