spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

#include "Missile.h"

        
tbVideo* g_pVideo = NULL;   // Das Video
char acVideoFilename[10] = "intro.avi"; // Der Dateiname

// Initialisiert den Spielzustand
tbResult CIntro::Init()
{
    // Laden...
    if(Load()) TB_ERROR("Fehler beim Laden des Spielzustands!", TB_ERROR);

    g_pVideo = new tbVideo;
    if(g_pVideo->Init(acVideoFilename))
    {
        // Fehler!
        Exit();
        TB_ERROR("Fehler beim Laden des Videos", TB_ERROR);
    }

    // Video mit Looping abspielen
    g_pVideo->Play(TRUE);

    return TB_OK;
}

// Fährt den Spielzustand herunter
tbResult CIntro::Exit()
{
    //  Video löschen und Entladen...
    TB_SAFE_DELETE(g_pVideo);
    Unload();

    return TB_OK;
}

// Lädt den Spielzustand
tbResult CIntro::Load()
{
    return TB_OK;
}

// Entlädt den Spielzustand
tbResult CIntro::Unload()
{
    return TB_OK;
}

// Bewegt den Spielzustand
tbResult CIntro::Move(float fTime) {
    // Wenn eine der typischen Tasten gedrückt wurde: zum Hauptmenü
    /* if(g_pbButtons[TB_KEY_NUMPADENTER] ||
       g_pbButtons[TB_KEY_RETURN] ||
       g_pbButtons[TB_KEY_SPACE] ||
       g_pbButtons[TB_MOUSE_BUTTON(0)] ||
       g_pbButtons[TB_MOUSE_BUTTON(1)])
    {
        // Beenden
        tbDelay(100);
        PostQuitMessage(0);
        return TB_OK;
        // g_pMissile->SetGameState(GS_MAIN_MENU);
    }
    else { */
    // Das Video verarbeiten
    g_pVideo->Process();
    // }

    return TB_OK;
}

// Rendert den Spielzustand
tbResult CIntro::Render(float fTime)
{
    SIntroVertex aVertex[4];

    // Wenn die Videotextur gerade gesperrt ist, warten wir so lange,
    // bis sie es nicht mehr ist.
    while(g_pVideo->GetRenderer()->IsTextureLocked()) {}

    // Die Szene beginnen
    tbDirect3D::GetDevice()->BeginScene();

    // ------------------------------------------------------------------

    // Vertexformat und Videotextur setzen, Z-Buffer aus
    tbDirect3D::SetFVF(VERTEX_INTRO_FVF);
    tbDirect3D::SetTexture(0, g_pVideo->GetRenderer()->GetTexture());
    tbDirect3D::SetRS(D3DRS_ZENABLE, D3DZB_FALSE);

    // Die vier Vertizes erstellen (Rechteck)
    // Links unten
    aVertex[0].vPosition = tbVector3(0.0f, tbDirect3D::GetScreenSize().y, 0.5f);
    aVertex[0].fRHW = 1.0f;
    aVertex[0].Color = tbColor(0.0f, 0.0f, 0.0f);
    aVertex[0].vTex0 = tbVector2(0.0f, g_pVideo->GetRenderer()->GetBottomRightTex().y);

    // Links oben
    aVertex[1].vPosition = tbVector3(0.0f, 0.0f, 0.0f);
    aVertex[1].fRHW = 1.0f;
    aVertex[1].Color = tbColor(0.0f, 0.0f, 0.0f);
    aVertex[1].vTex0 = tbVector2(0.0f, 0.0f);

    // Rechts unten
    aVertex[2].vPosition = tbVector3(tbDirect3D::GetScreenSize().x, tbDirect3D::GetScreenSize().y, 0.5f);
    aVertex[2].fRHW = 1.0f;
    aVertex[2].Color = tbColor(0.0f, 0.0f, 0.0f);
    aVertex[2].vTex0 = g_pVideo->GetRenderer()->GetBottomRightTex();

    // Rechts oben
    aVertex[3].vPosition = tbVector3(tbDirect3D::GetScreenSize().x, 0.0f, 0.5f);
    aVertex[3].fRHW = 1.0f;
    aVertex[3].Color = tbColor(0.0f, 0.0f, 0.0f);
    aVertex[3].vTex0 = tbVector2(g_pVideo->GetRenderer()->GetBottomRightTex().x, 0.0f);

    // Als Dreiecksfolge zeichnen
    tbDirect3D::GetDevice()->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, aVertex, sizeof(SIntroVertex));

    // ------------------------------------------------------------------

    // Szene beenden und darstellen
    tbDirect3D::GetDevice()->EndScene();
    tbDirect3D::GetDevice()->Present(NULL, NULL, NULL, NULL);

    return TB_OK;
}

Quellcode

// Klasse für das Intro
class CIntro
{
public:
    // Struktur für einen Vertex
    #define VERTEX_INTRO_FVF (D3DFVF_XYZRHW | D3DFVF_TEX1)
    struct SIntroVertex
    {
    tbVector3   vPosition;
    float       fRHW;
    D3DCOLOR    Color;
    tbVector2   vTex0;
    };

    // Konstruktor
    inline CIntro() {ZeroMemory(this, sizeof(CIntro));}
    
    // Methoden
    tbResult Init();                // Initialisierung
    tbResult Exit();                // Herunterfahren
    tbResult Load();                // Laden
    tbResult Unload();              // Entladen
    tbResult Move(float fTime);     // Bewegen
    tbResult Render(float fTime);   // Rendern
};

Quellcode

#include <TriBase.h>
#include "intro.h"
#include "resource.h"

// Spielzustände
enum EGameState {
    GS_NONE,        // Kein Spielzustand
    GS_INTRO,       // Intro
    GS_MAIN_MENU    // Hauptmenü
};

// Die Spiel-Klasse
class CMissile
{
public:
    // Variablen
    // DirectX
    tbConfig                m_Config;       // Konfiguration
    PDIRECT3DSTATEBLOCK9    m_pStateBlock;  // Statusblock für Direct3D
    tbTextureManager*       m_pTexManager;  // Texturmanager

    // Die Spielzustände
    CIntro*                 m_pIntro;       // Intro
//  CMainMenu*              m_pMainMenu;    // Hauptmenü
    EGameState              m_GameState;    // Aktueller Spielzustand
    float                   m_fTime;        // Stoppuhr

    // Schriftarten
    tbFont*                 m_pFont1;
    tbFont*                 m_pFont2;
    tbFont*                 m_pFont3;
    tbFont*                 m_pFont4;
    tbFont*                 m_pFont5;
    tbFont*                 m_pFont6;
    tbFont*                 m_pFont7;

    // Methoden
    tbResult Init();                                // Initialisiert das Spiel komplett
    tbResult Exit();                                // Fährt das Spiel herunter
    tbResult Load();                                // Lädt die Spieldaten
    tbResult Unload();                              // Entlädt die Spieldaten
    tbResult Run();                                 // Lässt das Spiel laufen
    tbResult SetGameState(EGameState NewGameState); // Setzt einen neuen Spielzustand
    tbResult Move(float fTime);                     // Bewegt das Spiel
    tbResult Render(float fTime);                   // Rendert das Spiel
};

// Globale Variablen
extern CMissile*    g_pMissile;
extern float*       g_pfButtons;
extern BOOL*        g_pbButtons;
extern BOOL*        g_pbButtons;

Quellcode

// Include-Dateien

#include "missile.h"

// Globale Variablen
CMissile* g_pMissile = NULL;
float* g_pfButtons = NULL;
BOOL* g_pbButtons = NULL;

// Windows-Hauptfunktion
int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   char* pcCommandLine,
                   int iShowCommand)
{
    tbResult r;

    // Spiel initialisieren
    g_pMissile = new CMissile;
    r = g_pMissile->Init();
    if(r == TB_CANCELED)
    {
        // Der Konfigurationsdialog wurde abgebrochen!
        // Das Programm "leise" verlassen.
        TB_SAFE_DELETE(g_pMissile);
        return 0;
    }
    else if(r)
    {
        g_pMissile->Exit();
        TB_SAFE_DELETE(g_pMissile);
        MessageBox(NULL, "Fehler beim Initialisieren des Spiels!",
                   "Fehler", MB_OK | MB_ICONEXCLAMATION);
        return 1;
    }

    // Spiel laufen lassen
    if(g_pMissile->Run())
    {
        g_pMissile->Exit();
        TB_SAFE_DELETE(g_pMissile);
        MessageBox(NULL, "Fehler im Spiel!",
                   "Fehler", MB_OK | MB_ICONEXCLAMATION);
        return 1;
    }

    // Spiel verlassen
    g_pMissile->Exit();
    TB_SAFE_DELETE(g_pMissile);

    return 0;
}


// Lädt das Spiel
tbResult CMissile::Load()
{

    // Direct3D initialisieren
    if(tbDirect3D::Init(&m_Config, "Missile",
                        NULL, LoadIcon(GetModuleHandle(NULL),
                        MAKEINTRESOURCE(IDI_ICON1))))
    {
        // Fehler!
        TB_ERROR("Fehler beim Initialisieren von Direct3D!", TB_ERROR);
    }

    // Statusblock für Direct3D erstellen
    tbDirect3D::GetDevice()->CreateStateBlock(D3DSBT_ALL, &m_pStateBlock);

    // Texturmanager erstellen
    if(tbTextureManager::Init())
    {
        // Fehler!
        TB_ERROR("Texturmanager konnte nicht initialisiert werden!", TB_ERROR);
    }

    // DirectInput initialisieren
    if(tbDirectInput::Init())
    {
        // Fehler!
        TB_ERROR("DirectInput konnte nicht initialisiert werden!", TB_ERROR);
    }

    // Speicher für die analogen Knöpfe reservieren
    g_pfButtons = new float[tbDirectInput::GetNumButtons()];
    g_pbButtons = new BOOL[tbDirectInput::GetNumButtons()];

    // Schriftarten laden
    m_pFont1 = new tbFont;
    if(m_pFont1->Init("Data\\fonts\\font1.tga", "Data\\fonts\\font1.tbf"))
    {
        // Fehler!
        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"))
    {
        // Fehler!
        TB_ERROR("Fehler beim Laden der Schriftart Data\\fonts\\font2!", TB_ERROR);
    }

    m_pFont3 = new tbFont;
    if(m_pFont3->Init("Data\\fonts\\font3.tga", "Data\\fonts\\font3.tbf"))
    {
        // Fehler!
        TB_ERROR("Fehler beim Laden der Schriftart Data\\fonts\\font3!", TB_ERROR);
    }

    m_pFont4 = new tbFont;
    if(m_pFont4->Init("Data\\fonts\\font4.tga", "Data\\fonts\\font4.tbf"))
    {
        // Fehler!
        TB_ERROR("Fehler beim Laden der Schriftart Data\\fonts\\font4!", TB_ERROR);
    }
    m_pFont5 = new tbFont;
    if(m_pFont5->Init("data\\fonts\\font5.tga", "Data\\fonts\\font5.tbf"))
    {
        // Fehler!
        TB_ERROR("Fehler beim Laden der Schriftart Data\\fonts\\font5!", TB_ERROR);
    }

    m_pFont6 = new tbFont;
    if(m_pFont6->Init("data\\fonts\\font6.tga", "Data\\fonts\\font6.tbf"))
    {
        // Fehler!
        TB_ERROR("Fehler beim Laden der Schriftart Data\\fonts\\font6!", TB_ERROR);
    }
    m_pFont7 = new tbFont;
    if(m_pFont7->Init("data\\fonts\\font7.tga", "Data\\fonts\\font7.tbf"))
    {
        // Fehler!
        TB_ERROR("Fehler beim Laden der Schriftart Data\\fonts\\font7!", TB_ERROR);
    }

    return TB_OK;
}

// Setzt einen neuen Spielzustand
tbResult CMissile::SetGameState(EGameState NewGameState)
{
    tbResult r = TB_OK;

    // Alten Spielzustand entladen
    switch(m_GameState)
    {
    case GS_INTRO:      m_pIntro->Exit();           break;
    // case GS_MAIN_MENU:   m_pMainMenu->Exit();        break;
    }

    // Zeit zurücksetzen
    m_fTime = 0.0f;

    // Neuen Spielzustand laden
    m_GameState = NewGameState;
    switch(m_GameState)
    {
    case GS_INTRO:      r = m_pIntro->Init();       break;
    // case GS_MAIN_MENU:   r = m_pMainMenu->Init();    break;
    }

    // Eventuelle Fehler abfangen
    if(r) TB_ERROR("Fehler beim Laden des Spielzustands!", TB_ERROR);

    return TB_OK;
}

// Initialisiert das Spiel komplett
tbResult CMissile::Init()
{
    tbResult r;

    // Alles zurücksetzen
    ZeroMemory(this, sizeof(CMissile));

    // Die TriBase-Engine initialisieren und den Konfigurationsdialog aufrufen
    if(tbInit()) return TB_ERROR;
    r = tbDoConfigDialog(&m_Config);
    if(r == TB_CANCELED) return TB_CANCELED;
    else if(r) TB_ERROR("Engine konnte nicht initialisiert werden!", r);

    // Laden...
    if(Load()) TB_ERROR("Fehler beim Laden des Spiels!", TB_ERROR);

    // Klassen für alle Spielzustände erstellen
    m_pIntro = new CIntro;
    // m_pMainMenu = new CMainMenu;

    // Wir beginnen beim Intro!
    SetGameState(GS_INTRO);

    return TB_OK;
}

// Bewegt das Spiel
tbResult CMissile::Move(float fTime)
{
    tbResult r = TB_OK;

    // Eingabegeräte abfragen
    tbDirectInput::GetState(g_pfButtons, g_pbButtons);

    // Aktuellen Spielzustand bewegen
    switch(m_GameState)
    {
    case GS_INTRO:      r = m_pIntro->Move(fTime);      break;
    // case GS_MAIN_MENU:   r = m_pMainMenu->Move(fTime);   break;
    }

    // Eventuelle Fehler abfangen
    if(r) TB_ERROR("Fehler beim Bewegen des Spielzustands!", TB_ERROR);

    // Zeit addieren
    m_fTime += fTime;

    return TB_OK;
}

// Rendert das Spiel
tbResult CMissile::Render(float fTime)
{
    tbResult r = TB_OK;

    // Aktuellen Spielzustand rendern
    switch(m_GameState)
    {
    case GS_INTRO:      r = m_pIntro->Render(fTime);    break;
    // case GS_MAIN_MENU:   r = m_pMainMenu->Render(fTime); break;
    }

    // Eventuelle Fehler abfangen
    if(r) TB_ERROR("Fehler beim Rendern des Spielzustands!", TB_ERROR);

    // Bildpuffer anzeigen
    if(tbDirect3D::Present())
    {
        // Anzeigen ist fehlgeschlagen!
        // Wahrscheinlich läuft das Programm im Vollbildmodus und es
        // wurde zwischenzeitlich minimiert.
        // Wir initialisieren das Spiel komplett neu.

        // Aktuellen Spielzustand entladen
        switch(m_GameState)
        {
        case GS_INTRO:      m_pIntro->Unload();     break;
        // case GS_MAIN_MENU:   m_pMainMenu->Unload();  break;
        }

        // Das ganze Spiel entladen und dann wieder neu laden
        Unload();
        Load();

        // Aktuellen Spielstatus neu laden
        switch(m_GameState)
        {
        case GS_INTRO:      m_pIntro->Load();       break;
        // case GS_MAIN_MENU:   m_pMainMenu->Load();    break;
        }
    }

    return TB_OK;
}

// Move- und Render-Funktion (Kapselung)
tbResult Move(float fTime) {return g_pMissile->Move(fTime);}
tbResult Render(float fTime) {return g_pMissile->Render(fTime);}

// Lässt das Spiel laufen
tbResult CMissile::Run()
{
    // Nachrichtenschleife betreten
    if(tbDoMessageLoop(::Move, ::Render))
    {
        // Fehler!
        TB_ERROR("Fehler in der Nachrichtenschleife!", TB_ERROR);
    }

    return TB_OK;
}

tbResult CMissile::Exit()
{
    // Kein Spielstatus (aktuellen Spielstatus entladen)
    SetGameState(GS_NONE);

    // Entladen...
    Unload();

    // Die Klassen für die Spielzustände löschen
    TB_SAFE_DELETE(m_pIntro);
//  TB_SAFE_DELETE(m_pMainMenu);

    // Die Engine herunterfahren
    tbExit();

    return TB_OK;
}

// Entlädt das Spiel
tbResult CMissile::Unload()
{
    // Schriftarten löschen
    TB_SAFE_DELETE(m_pFont1);
    TB_SAFE_DELETE(m_pFont2);
    TB_SAFE_DELETE(m_pFont3);
    TB_SAFE_DELETE(m_pFont4);
    TB_SAFE_DELETE(m_pFont5);
    TB_SAFE_DELETE(m_pFont6);
    TB_SAFE_DELETE(m_pFont7);

    // DirectX-Klassen löschen
    TB_SAFE_RELEASE(m_pStateBlock);
    TB_SAFE_DELETE_ARRAY(g_pfButtons);
    TB_SAFE_DELETE_ARRAY(g_pbButtons);
    tbDirect3D::Exit();
    tbDirectInput::Exit();
    tbTextureManager::Exit();

    return TB_OK;
}