D:/Zythum/DinoKod/Mod_Aeternis_Client/A_WinCredits.cpp

//---------------------------------------------------------------------------------------------
//      This file is a part of "DinoKod".
//      Copyright © 2003 Dino Productions. All Rights Reserved.
//      
//      File                    : WinCredits.cpp
//      Author                  : Cedric Stanus
//      Date                    : 29/08/2003
//      Modification    :
//
//---------------------------------------------------------------------------------------------
#include "Common/Time.h"
#include "Render/Render.h"
#include "Render/Font.h"
#include "Common/LocalizedString.h"
#include "Common/Directory.h"
#include "Sound/SoundDS.h"

#include "Mod_Aeternis_Client/A_Interface.h"
#include "Mod_Aeternis_Client/A_WinCredits.h"

#define GUIDIR( __gui ) KStr( "GUI/%s/%s", GETLANGUAGEPREFIX(), __gui )

#define BUTTONBACK                      GUIDIR("Return")
#define BUTTONBACKHL            GUIDIR("Return_HL")
#define BUTTONBACKC                     GUIDIR("Return_C")

//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
KAWinCredits::KAWinCredits( KWin* pFather, KFPt& Pos, KFPt& Size, KInterface* pInterface )
: KWin( pFather, Pos, Size, pInterface )
{
        m_BackGround    = KSHADER_NO;
        m_TypeMusic             = KTRACK_NO;

        KFPt    ButtonSize = KFPt( 0.25f, 0.04f );
        // Button Back
        m_pButtonBack = new KButton( this, KFPt( 0.8f, 0.9f ) - ButtonSize / 2, ButtonSize, m_pInterface, BUTTONBACK, BUTTONBACKHL, BUTTONBACKC );

        KStr sTextPath = g_Directory.GetPath( KStr( "Text" ), 1 ) ;
        sTextPath += "Credits.ini" ;
        m_pIniFile = new KIni( sTextPath ) ;

        m_uiNbCreditsPage       = 0 ;
        m_fTimeForEachPage      = 0 ;
        m_uCurrentPage          = -1 ;
        m_uLastPage                     = -2 ;
        m_pTabPages                     = NULL ;

        KSound*         pSound = ((KAInterface*)m_pInterface)->GetpSound();
        if( pSound )
        {
                // Sons
                m_TypeWriterSound       = pSound->LoadTrack( KStr("GUI/Machine.ogg"), KSTT_SOUND );
                m_TypeWriterCRSound = pSound->LoadTrack( KStr("GUI/Machine2.ogg"), KSTT_SOUND );
        
                // Musique
                m_TypeMusic = pSound->LoadStreamTrack( KStr("Musics/Woodoo.ogg") );
        }

        if(m_pIniFile)
        {
                LoadIni() ;
        }
}

//------------------------------------------------------------------------------------------
KAWinCredits::~KAWinCredits()
{
        for(u32 uCptPages = 0 ; uCptPages < m_uiNbCreditsPage ; uCptPages ++)
        {
                // On parcours tous les textes de la page
/*              for(u32 uCptText = 0 ; uCptText < m_pTabPages[uCptPages].uNbTexts ; uCptText ++)
                {
                        SafeDeletep( m_pTabPages[uCptPages].pText[uCptText] );
                }
*/
                SafeDeletev( m_pTabPages[uCptPages].pText );
                SafeDeletev( m_pTabPages[uCptPages].pInitText );

                // On parcours toutes les images de la page
/*
                for(u32 uCptImages = 0 ; uCptImages < m_pTabPages[uCptPages].uNbImages ; uCptImages ++)
                {
                        SafeDeletep( m_pTabPages[uCptPages].pBitmap[uCptImages] );
                }
*/
                SafeDeletev( m_pTabPages[uCptPages].pBitmap );
        }

        SafeDeletev( m_pTabPages );
        SafeDeletep( m_pIniFile );

        KSound*         pSound = ((KAInterface*)m_pInterface)->GetpSound();
        if( pSound )
        {
                // Sons
                pSound->UnloadTrack( m_TypeWriterSound );
                pSound->UnloadTrack( m_TypeWriterCRSound );

                // Musique
                pSound->UnloadStreamTrack( m_TypeMusic );
        }
}

//------------------------------------------------------------------------------------------
bool KAWinCredits::LoadIni()
{
        m_fTimeForEachPage              = m_pIniFile->ReadFloat("GLOBAL","TIMEFOREACHPAGE",5000) ;
        m_uiNbCreditsPage               = m_pIniFile->ReadInt("GLOBAL","NB_CREDITS_PAGES",0) ;
        m_fTimeForTypeWriter    = m_pIniFile->ReadFloat("GLOBAL","TIMEFORTYPEwriter",70) ;
        m_fRollSpeed                    = m_pIniFile->ReadFloat("GLOBAL","ROLLSPEED",0.2f) ;
        KFPt ButtonSize                 = KFPt( 0.20f, 0.04f );

        if(m_uiNbCreditsPage == 0)
                return false ;

        m_pTabPages = new sPages[m_uiNbCreditsPage] ;

        // On parcours toutes les pages de credits
        for(u32 uCptPages = 0 ; uCptPages < m_uiNbCreditsPage ; uCptPages ++)
        {
                char cTempSection[256] = "" ;
                sprintf(cTempSection,"CREDIT%i",uCptPages) ;
                u32 uNbTexts    = m_pIniFile->ReadInt(cTempSection,"NB_TEXTS",0) ;
                u32 uNbImages   = m_pIniFile->ReadInt(cTempSection,"NB_IMAGES",0) ;
                m_pTabPages[uCptPages].drawMode = (DRAW_MODE)m_pIniFile->ReadInt(cTempSection,"DRAW_MODE",0) ;

                m_pTabPages[uCptPages].pText            = NULL ;
                m_pTabPages[uCptPages].pBitmap          = NULL ;
                m_pTabPages[uCptPages].pInitText        = NULL ;
                m_pTabPages[uCptPages].uNbImages        = uNbImages ;
                m_pTabPages[uCptPages].uNbTexts         = uNbTexts ;
                m_pTabPages[uCptPages].fValueToRoll     = 1.0f ;

                if(uNbTexts != 0)
                {
                        m_pTabPages[uCptPages].pInitText = new KStr[uNbTexts] ;
                        m_pTabPages[uCptPages].pText = new KText*[uNbTexts] ;
                }
                if(uNbImages != 0)
                        m_pTabPages[uCptPages].pBitmap = new KWinBitmap*[uNbImages] ;

                m_pTabPages[uCptPages].bLoaded = false ;

                // On parcours tous les textes de la page
                for(u32 uCptText = 0 ; uCptText < uNbTexts ; uCptText ++)
                {
                        char cTempText[256] = "" ;
                        sprintf(cTempText,"TEXT%i",uCptText) ;
                        char *pString = (char*)m_pIniFile->ReadString(cTempSection,cTempText,"") ;
                        GetInfo(pString) ;
                        m_pTabPages[uCptPages].pText[uCptText] = new KText(this, KFPt( m_sInfo.fPosX, m_sInfo.fPosY ) - ButtonSize / 2, ButtonSize, m_pInterface, m_sInfo.cName) ;
                        m_pTabPages[uCptPages].pText[uCptText]->Hide() ;
//                      m_pTabPages[uCptPages].pInitText[uCptText] = new char[256] ;
                        m_pTabPages[uCptPages].pInitText[uCptText] = KStr(m_sInfo.cName);
                }
                // On parcours toutes les images de la page

                for(u32 uCptImages = 0 ; uCptImages < uNbImages ; uCptImages ++)
                {
                        char cTempImage[256] = "" ;
                        sprintf(cTempImage,"IMAGE%i",uCptImages) ;
                        char *pString = (char*)m_pIniFile->ReadString(cTempSection,cTempImage,"") ;
                        GetInfo(pString) ;
                        m_pTabPages[uCptPages].pBitmap[uCptImages] = new KWinBitmap(this, KFPt( m_sInfo.fPosX, m_sInfo.fPosY ), KFPt( m_sInfo.fSizeX, m_sInfo.fSizeY ), m_pInterface,KStr(m_sInfo.cName)) ;
                        m_pTabPages[uCptPages].pBitmap[uCptImages]->Hide() ;
                }

        }

        return true ;
}

//------------------------------------------------------------------------------------------
void KAWinCredits::Display()
{
        u8              FadeAlpha = (u8)(255.0f * GetFade());

        m_pInterface->ShowMouse();
        DrawQuad( 0.0f, 0.0f, 1.0f, 1.0f, m_BackGround, KRGBA( 255, 255, 255, FadeAlpha ) );
        DrawQuad( 0.05f, 0.25f, 0.9f, 0.6f, KSHADER_NO, KRGBA( 56, 91, 149, FadeAlpha / 4 ), KRGB_BLACK, KRM_MODULATE );
}

//------------------------------------------------------------------------------------------
void KAWinCredits::Manage()
{
        if(m_uLastPage == -2)
        {
                m_uLastPage = -1 ;
                NextPage() ;
        }
        KTIME currentTime = g_Time.GetTime() ;

        if(((currentTime - m_LastTime) >= m_fTimeForEachPage) && (m_pTabPages[m_uCurrentPage].bLoaded))
                NextPage() ;

#ifdef _DEBUG
        if( GetAsyncKeyState( VK_SPACE ) && ((currentTime - m_LastTime) > 500)/* && (m_pTabPages[m_uCurrentPage].bLoaded) */)
                NextPage();
#endif

        DisplayPage(m_uCurrentPage) ;

        // Back
        if( m_pButtonBack->IsClicked() )
        {
                m_pButtonBack->Reset() ;
                ((KAInterface*)m_pInterface)->SetWin( KAIW_START );
        }
}

//------------------------------------------------------------------------------------------
void KAWinCredits::DisplayPage(s32 uPage)
{
        if(uPage < 0)
                return ;

        if(m_pTabPages[uPage].bLoaded)
                return ;

        if(m_pTabPages[uPage].drawMode == DRAW_MODE_ROLL)
        {
                if(m_pTabPages[uPage].bInitDrawMode)
                {
                        m_pTabPages[uPage].bInitDrawMode = false ;
                        for(u32 uCptText = 0 ; uCptText < m_pTabPages[uPage].uNbTexts ; uCptText ++)
                        {
                                KFPt pos = m_pTabPages[uPage].pText[uCptText]->GetPos() ;
                                if(m_pTabPages[uPage].fValueToRoll == 1.0f)
                                        pos.y += m_pTabPages[uPage].fValueToRoll ;
                                else
                                        pos.y += (1.0f - m_pTabPages[uPage].fValueToRoll) ;
                                m_pTabPages[uPage].pText[uCptText]->SetPos(pos) ;
                        }
                        for(u32 uCptImages = 0 ; uCptImages < m_pTabPages[uPage].uNbImages ; uCptImages ++)
                        {
                                KFPt pos = m_pTabPages[uPage].pBitmap[uCptImages]->GetPos() ;
                                if(m_pTabPages[uPage].fValueToRoll == 1.0f)
                                        pos.y += m_pTabPages[uPage].fValueToRoll ;
                                else
                                        pos.y += (1.0f - m_pTabPages[uPage].fValueToRoll) ;
                                m_pTabPages[uPage].pBitmap[uCptImages]->SetPos(pos) ;
                        }
                        m_pTabPages[uPage].fValueToRoll = 1.0f ;
                }

                float fTimeElapsed = (float)(g_Time.GetTime() - m_pTabPages[uPage].lastTime) ;
                m_pTabPages[uPage].lastTime = g_Time.GetTime() ;
                float fStep = (fTimeElapsed * m_fRollSpeed) / 1000.0f ;
                if((m_pTabPages[uPage].fValueToRoll - fStep) < 0)
                        fStep = m_pTabPages[uPage].fValueToRoll ;
 
                m_pTabPages[uPage].fValueToRoll -= fStep ;

                for(u32 uCptText = 0 ; uCptText < m_pTabPages[uPage].uNbTexts ; uCptText ++)
                {
                        KFPt pos = m_pTabPages[uPage].pText[uCptText]->GetPos() ;
                        pos.y -= fStep ;
                        m_pTabPages[uPage].pText[uCptText]->SetPos(pos) ;

                        if(pos.y >= 0.82f)
                                m_pTabPages[uPage].pText[uCptText]->Hide() ;
                        else
                                m_pTabPages[uPage].pText[uCptText]->Show() ;
                }
                for(u32 uCptImages = 0 ; uCptImages < m_pTabPages[uPage].uNbImages ; uCptImages ++)
                {
                        KFPt pos = m_pTabPages[uPage].pBitmap[uCptImages]->GetPos() ;
                        pos.y -= fStep ;
                        m_pTabPages[uPage].pBitmap[uCptImages]->SetPos(pos) ;
                }

                if(m_pTabPages[uPage].fValueToRoll <= 0)
                {
                        m_pTabPages[uPage].bLoaded = true ;
                        m_LastTime = g_Time.GetTime() ;
                }
        }
        if(m_pTabPages[uPage].drawMode == DRAW_MODE_TYPEWRITER)
        {
                if(m_pTabPages[uPage].bInitDrawMode)
                {
                        m_pTabPages[uPage].bInitDrawMode = false ;
                        m_pTabPages[uPage].uCurrentText = 0 ;
                        m_pTabPages[uPage].uPosCharacter = 0 ;

                        for(u32 uCptText = 0 ; uCptText < m_pTabPages[uPage].uNbTexts ; uCptText ++)
                        {
                                m_pTabPages[uPage].pText[uCptText]->SetpText("") ;
                        }
                }

                float fTimeElapsed = (float)g_Time.GetTime() - (float)m_pTabPages[uPage].lastTime ;

                if(fTimeElapsed < m_fTimeForTypeWriter)
                        return ;
                m_pTabPages[uPage].lastTime = g_Time.GetTime() ;

                char cTemp[1024] = "" ;
                strncpy( cTemp, m_pTabPages[uPage].pInitText[m_pTabPages[uPage].uCurrentText].GetpString(), m_pTabPages[uPage].uPosCharacter + 1 ) ;
                m_pTabPages[uPage].pText[m_pTabPages[uPage].uCurrentText]->SetpText(cTemp) ;

                KSound* pSound = ((KAInterface*)m_pInterface)->GetpSound();
                if( pSound )
                        pSound->Play( m_TypeWriterSound );

                if(strlen(m_pTabPages[uPage].pText[m_pTabPages[uPage].uCurrentText]->GetpText()) >= m_pTabPages[uPage].pInitText[m_pTabPages[uPage].uCurrentText].GetLength() )
                {
                        m_pTabPages[uPage].uCurrentText ++ ;
                        m_pTabPages[uPage].uPosCharacter = 0 ;
                        m_pTabPages[uPage].lastTime += 500 ;
                        if( pSound )
                                pSound->Play( m_TypeWriterCRSound );
                }
                else
                        m_pTabPages[uPage].uPosCharacter ++ ;

                if(m_pTabPages[uPage].uCurrentText == m_pTabPages[uPage].uNbTexts)
                {
                        m_pTabPages[uPage].bLoaded = true ;
                        m_LastTime = g_Time.GetTime() ;
                }
        }
}

//------------------------------------------------------------------------------------------
void KAWinCredits::NextPage()
{
        m_uLastPage = m_uCurrentPage ;
        m_uCurrentPage ++ ;

        if(m_uCurrentPage == m_uiNbCreditsPage)
                m_uCurrentPage = 0 ;

        UnLoadPage(m_uLastPage) ;
        LoadPage(m_uCurrentPage) ;

        m_LastTime = g_Time.GetTime() ;
}

//------------------------------------------------------------------------------------------
void KAWinCredits::LoadPage(s32 uPage)
{
        if(uPage < 0)
                return ;

        for(u32 uCptText = 0 ; uCptText < m_pTabPages[uPage].uNbTexts ; uCptText ++)
        {
                m_pTabPages[uPage].pText[uCptText]->Show() ;
                m_pTabPages[uPage].pText[uCptText]->StartFadeIn() ;
        }

        for(u32 uCptImages = 0 ; uCptImages < m_pTabPages[uPage].uNbImages ; uCptImages ++)
        {
                m_pTabPages[uPage].pBitmap[uCptImages]->Show() ;
                m_pTabPages[uPage].pBitmap[uCptImages]->StartFadeIn() ;
        }

        if(m_pTabPages[uPage].drawMode == DRAW_MODE_FADE)
                m_pTabPages[uPage].bLoaded = true ;

        m_pTabPages[uPage].bInitDrawMode        = true ;
        m_pTabPages[uPage].lastTime                     = g_Time.GetTime() ;
}

//------------------------------------------------------------------------------------------
void KAWinCredits::UnLoadPage(s32 uPage,bool bForceHide)
{
        if(uPage < 0)
                return ;

        for(u32 uCptText = 0 ; uCptText < m_pTabPages[uPage].uNbTexts ; uCptText ++)
        {
                if(bForceHide)
                        m_pTabPages[uPage].pText[uCptText]->Hide() ;
                else
                        m_pTabPages[uPage].pText[uCptText]->StartFadeOut() ;
        }

        for(u32 uCptImages = 0 ; uCptImages < m_pTabPages[uPage].uNbImages ; uCptImages ++)
        {
                if(bForceHide)
                        m_pTabPages[uPage].pBitmap[uCptImages]->Hide() ;
                else
                        m_pTabPages[uPage].pBitmap[uCptImages]->StartFadeOut() ;
        }

        m_pTabPages[uPage].bLoaded = false ;

}

//------------------------------------------------------------------------------------------
sInfo KAWinCredits::GetInfo(char *pString)
{
        u64 uSize = strlen(pString) ;

        u32 uiCptString = 0 ;
        u32 uiCptTemp = 0 ;
        char cTemp[256] = "" ;
        while((pString[uiCptString] != ';') && (uiCptString < uSize))
        {
                cTemp[uiCptTemp] = pString[uiCptString] ;
                uiCptString ++ ;
                uiCptTemp++ ;
        }
        strcpy(m_sInfo.cName,cTemp) ;
        strncpy(cTemp,"",256) ;
        uiCptString ++ ;
        uiCptTemp = 0 ;
        while((pString[uiCptString] != ';') && (uiCptString < uSize))
        {
                cTemp[uiCptTemp] = pString[uiCptString] ;
                uiCptString ++ ;
                uiCptTemp++ ;
        }
        m_sInfo.fPosX = (float)atof(cTemp) ;
        strncpy(cTemp,"",256) ;
        uiCptString ++ ;
        uiCptTemp = 0 ;

        while((pString[uiCptString] != ';') && (uiCptString < uSize))
        {
                cTemp[uiCptTemp] = pString[uiCptString] ;
                uiCptString ++ ;
                uiCptTemp++ ;
        }
        m_sInfo.fPosY = (float)atof(cTemp) ;
        strncpy(cTemp,"",256) ;
        uiCptString ++ ;
        uiCptTemp = 0 ;

        if(uiCptString >= uSize)
                return m_sInfo ;

        while((pString[uiCptString] != ';') && (uiCptString < uSize))
        {
                cTemp[uiCptTemp] = pString[uiCptString] ;
                uiCptString ++ ;
                uiCptTemp++ ;
        }
        m_sInfo.fSizeX = (float)atof(cTemp) ;
        strncpy(cTemp,"",256) ;
        uiCptString ++ ;
        uiCptTemp = 0 ;

        while((pString[uiCptString] != ';') && (uiCptString < uSize))
        {
                cTemp[uiCptTemp] = pString[uiCptString] ;
                uiCptString ++ ;
                uiCptTemp++ ;
        }
        m_sInfo.fSizeY = (float)atof(cTemp) ;
        strncpy(cTemp,"",256) ;
        uiCptString ++ ;
        uiCptTemp = 0 ;

        return m_sInfo ;
}

//------------------------------------------------------------------------------------------
void KAWinCredits::Load()
{
        m_uLastPage = -2 ;
        m_uCurrentPage = -1 ;

        KWin::Load();

        for(u32 uCptPages = 0 ; uCptPages < m_uiNbCreditsPage ; uCptPages ++)
        {
                UnLoadPage(uCptPages,true) ;

                for(u32 uCptImages = 0 ; uCptImages < m_pTabPages[uCptPages].uNbImages ; uCptImages ++)
                {
                        m_pTabPages[uCptPages].pBitmap[uCptImages]->LoadShader() ;
                }
        }

        m_BackGround = m_pRender->GetpShaderBank()->LoadShader( GUIDIR("Credits_bg") );
}

//------------------------------------------------------------------------------------------
void KAWinCredits::Unload()
{
        KWin::Unload();

        for(u32 uCptPages = 0 ; uCptPages < m_uiNbCreditsPage ; uCptPages ++)
        {
                for(u32 uCptImages = 0 ; uCptImages < m_pTabPages[uCptPages].uNbImages ; uCptImages ++)
                {
                        m_pTabPages[uCptPages].pBitmap[uCptImages]->UnLoadShader() ;
                }
        }

        m_pRender->GetpShaderBank()->UnloadShader( m_BackGround );
}

//------------------------------------------------------------------------------------------
void KAWinCredits::OnShow()
{
        KWin::OnShow();

        ((KAInterface*)m_pInterface)->StopMenuMusic();

        KSound*         pSound = ((KAInterface*)m_pInterface)->GetpSound();
        if( pSound )
                pSound->PlayStreamTrack( m_TypeMusic, true );
}

//------------------------------------------------------------------------------------------
void KAWinCredits::OnHide()
{
        KWin::OnHide();

        ((KAInterface*)m_pInterface)->PlayMenuMusic();

        KSound*         pSound = ((KAInterface*)m_pInterface)->GetpSound();
        if( pSound )
                pSound->StopStreamTrack( m_TypeMusic, true );
}

---