spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

// FLASH - DEFINITION ALLGEMEINER SPIELFUNKTIONEN

//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''



//***************************************************************

// FLASH - INCLUDES

//***************************************************************


#include "Flash.h"

//***************************************************************

// GLOBALE VARIABLEN

//***************************************************************

CFlash*     g_pFlash = NULL;
float*      g_pfButtons = NULL;
BOOL*       g_pbButtons = NULL;
//***************************************************************

// FLASH - WINMAIN()

//***************************************************************

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, char* pcCommandLine, int iShowCommand)
{
    // Spiel initialisieren

    g_pFlash = new CFlash;
    tbResult r = g_pFlash->Init();
    if(r == TB_CANCELED)
    {
        TB_SAFE_DELETE(g_pFlash)

        return 0;
    }
    else if(r)
    {
        g_pFlash->Exit();
        TB_SAFE_DELETE(g_pFlash);
        // Messagebox hier


        return 1;
    }

    // Spiel laufen lassen

    if(g_pFlash->Run())
    {
        g_pFlash->Exit();
        TB_SAFE_DELETE(g_pFlash);
        // Messagebox hier


        return 1;
    }

    // Spiel verlassen

    g_pFlash->Exit();
    TB_SAFE_DELETE(g_pFlash);

    return 0;
}
//***************************************************************

// FLASH - INIT()

//***************************************************************

tbResult CFlash::Init()
{
    // Variablen 

    tbResult r;

    // Alles zurücksetzten

    ZeroMemory(this, sizeof(CFlash));

    // Die TriBase-Engine initialisieren

    if(tbInit())
    {
        return TB_ERROR;
    }
    r = tbDoConfigDialog(&m_Config);
    if(r == TB_CANCELED)
    {
        return TB_CANCELED;
    }
    else if(r)
    {
        TB_ERROR("Fehler beim Initialisieren der TriBase-Engine!", r);
    }

    // Laden

    if(Load())
    {
        TB_ERROR("Fehler beim Laden des Spiels!", TB_ERROR);
    }

    // Klassen für den Spielzustand erstellen

    m_pIntro    = new CIntro;
    m_pMainMenu = new CMainMenu;

    // Begin beim Intro

    SetGameState(GS_INTRO);

    return TB_OK;
}
//***************************************************************

// FLASH - EXIT()

//***************************************************************

tbResult CFlash::Exit()
{
    // Spiezustand auf GS_NONE setzen

    SetGameState(GS_NONE);

    // Entladen

    Unload();

    // Sicher beenden

    TB_SAFE_DELETE(m_pIntro);
    TB_SAFE_DELETE(m_pMainMenu);

    // Engine herunterfahren

    tbExit();

    return TB_OK;
}
//***************************************************************

// FLASH - LOAD()

//***************************************************************

tbResult CFlash::Load()
{
    // Direct3D initialisieren

    if(tbDirect3D::Instance().Init(&m_Config, "Flash", NULL, LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(1))))
    {
        TB_ERROR("Fehler beim Initialisieren von Direct3D!", TB_ERROR);
    }

    // Texturemanager initialisieren

    if(tbTextureManager::Instance().Init())
    {
        TB_ERROR("Fehler beim Initialisieren von dem TextureManager!", TB_ERROR);
    }

    // DirectSound initialisieren

    if(tbDirectSound::Instance().Init(&m_Config , NULL , DSSCL_PRIORITY , FALSE))
    {
        TB_ERROR("Fehler beim Initialisieren von DirectSound!", TB_ERROR);
    }

    // DirectInput initialisieren

    if(tbDirectInput::Instance().Init())
    {
        TB_ERROR("DirectInput konnte nicht initialisiert werden!", TB_ERROR);
    }

    // Speicher für die analogen Knöpfe reservieren

    g_pfButtons = new float[tbDirectInput::Instance().GetNumButtons()];
    g_pbButtons = new BOOL [tbDirectInput::Instance().GetNumButtons()];

    // Schriftarten laden

    m_pFont1 = new tbFont;
    if(m_pFont1->Init("Data\\Fonts\\Font1.tga" , "Data\\Fonts\\Font1.tbf"))
    {
        TB_ERROR("Fehler beim Laden der Schriftart Data\\Fonts\\Font1!", TB_ERROR);
    }
    m_pFont2 = new tbFont;
    if(m_pFont2->Init("Data\\Fonts\\Font2.tga" , "Data\\Fonts\\Font2.tbf"))
    {
        TB_ERROR("Fehler beim Laden der Schriftart Data\\Fonts\\Font2!", TB_ERROR);
    }
    m_pExitFont = new tbFont;
    if(m_pExitFont->Init("Data\\Fonts\\Beenden - Font.tga" , "Data\\Fonts\\Beenden - Font.tbf"))
    {
        TB_ERROR("Fehler beim Laden von der Schriftart Data\\Fonts\\Beenden - Font.tbf!", TB_ERROR);
    }

    return TB_OK;
}
//***************************************************************

// FLASH - UNLOAD()

//***************************************************************

tbResult CFlash::Unload()
{
    // Schriftarten löschen

    TB_SAFE_DELETE(m_pFont1);
    TB_SAFE_DELETE(m_pFont2);
    TB_SAFE_DELETE(m_pExitFont);

    // DirectX - Klassen löschen

    TB_SAFE_DELETE(g_pfButtons);
    TB_SAFE_DELETE(g_pbButtons);
    tbDirect3D::Instance().Exit();
    tbDirectSound::Instance().Exit();
    tbTextureManager::Instance().Exit();
    tbDirectInput::Instance().Exit();

    return TB_OK;
}
//***************************************************************

// Move- und Render-Funktion(Kapselung)

//***************************************************************

tbResult Move(float fTime)
{
    return g_pFlash->Move(fTime);
}
tbResult Render(float fTime)
{
    return g_pFlash->Render(fTime);
}
//***************************************************************

// FLASH - RUN()

//***************************************************************

tbResult CFlash::Run()
{
    // Nachrichtenschleife betreten

    if(tbDoMessageLoop(::Move, ::Render))
    {
        TB_ERROR("Fehler in der Nachrichtenschleife!", TB_ERROR);
    }

    return TB_OK;
}
//***************************************************************

// FLASH - SETGAMESTATE()

//***************************************************************

tbResult CFlash::SetGameState(EGameState NewGameState)
{
    // Variablen

    tbResult r;

    // Alten Spielzustand entladen

    switch(m_GameState)
    {
    case GS_INTRO:      m_pIntro->Exit();   break;
    case GS_MAINMENU:   m_pMainMenu->Exit();break;
    }

    // Zeit zurücksetzten

    m_fTime = 0.0f;

    // Neuen Spielzustand laden

    m_GameState = NewGameState;
    switch (m_GameState)
    {
    case GS_INTRO:      r = m_pIntro->Init();   break;
    case GS_MAINMENU:   r = m_pMainMenu->Init();break;
    }

    // Eventuelle Fehler abfangen

    /*if(r)
    {
        TB_ERROR("Fehler beim Laden des Spielzustands!", TB_ERROR);
    }*/

    return TB_OK;
}
//***************************************************************

// FLASH - MOVE()

//***************************************************************

tbResult CFlash::Move(float fTime)
{
    tbResult r = TB_OK;

    // Alle Eingabegeräte abfragen

    tbDirectInput::Instance().GetState(g_pfButtons, g_pbButtons);

    // Aktuellen Spielzustand bewegen

    switch (m_GameState)
    {
    case GS_INTRO:      r = m_pIntro->Move(fTime);   break;
    case GS_MAINMENU:   r = m_pMainMenu->Move(fTime);break;
    }

    // Ebentuellen Fehler abfangen

    if(r)
    {
        TB_ERROR("Fehler beim Bewegen des Spielzustands!", TB_ERROR);
    }

    // Zeit addieren

    m_fTime += fTime;

    return TB_OK;
}
//***************************************************************

// FLASH - RENDER()

//***************************************************************

tbResult CFlash::Render(float fTime)
{
    tbResult r = TB_OK;

    // Aktuellen Spielzustand rendern

    switch (m_GameState)
    {
    case GS_INTRO:      r = m_pIntro->Render(fTime);    break;
    case GS_MAINMENU:   r = m_pMainMenu->Render(fTime); break;
    }

    // Eventuelle Fehler abfangen

    if(r)
    {
        TB_ERROR("Fehler beim Render des Spielzustands!", TB_ERROR);
    }

    // Bildpuffer anzeigen

    if(tbDirect3D::Instance().Present())
    {
        TB_ERROR("Fehler beim Anzeigen des Bildpuffers!", TB_ERROR);
    }

    return TB_OK;
}
//***************************************************************

//***************************************************************