spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include "Game.hpp"

// Konstruktor
//
// Aufgabe: Allgemeine Initialisierungen
//
CGame::CGame ()
{
    m_pPlayer = NULL;
    m_pSpriteBackground = NULL;
    m_pSpriteAsteroid = NULL;
    m_pSpriteExplosion = NULL;
} // Konstruktor

// Init
//
// Aufgabe: Spieler, Hintergrund und Asteroid initialisieren
//
void CGame::Init ()
{
    // Neuen Spieler initialisieren
    m_pPlayer = new CPlayer;
    m_pPlayer->Init ();
    m_pPlayer->Reset ();

    /* Neuen Gegner initialisieren
    m_pOpponent = new COpponent;
    m_pOpponent->Init ();
    m_pOpponent->Reset ();
*/
    // Hintergrundbild (Sprite) laden
    m_pSpriteBackground = new CSprite;
    m_pSpriteBackground->Load ("Data/Background.bmp");

    // Sprite für Asteroiden laden
    m_pSpriteAsteroid = new CSprite;
    m_pSpriteAsteroid->Load ("Data/Asteroid.bmp", 20, 64, 64);
    m_pSpriteAsteroid->SetColorKey (255, 0, 255);

    // Sprite für Explosion laden
    m_pSpriteExplosion = new CSprite;
    m_pSpriteExplosion->Load ("Data/Asteroid.bmp", 20, 64, 64);
    m_pSpriteExplosion->SetColorKey (255, 0, 255);

    // Sound laden
    m_pMusic = NULL; 
    m_pMusic = new CSound (44100, AUDIO_S16SYS, 2, 4096);
    m_pMusic->LoadMusic("Data/test.wav",100);
    m_pMusic->PlayMusic();

    // Sound für Asteroiden-Explosion laden
    m_pSoundAsteroid = NULL;
    m_pSoundAsteroid = new CSound (44100, AUDIO_S16SYS, 2, 4096);
    m_pSoundAsteroid->LoadSound("Data/Asteroid_Explosion.wav", 100);

    // Font Lebensenergie
    m_pFontLive = NULL;
    m_pFontLive = new CFont();
    m_pFontLive->LoadFont("Data/sfd/FreeMono.ttf", 15);

    // Font Lebensenergie - Anzahl
    m_pFontNumb = NULL;
    m_pFontNumb = new CFont();
    m_pFontNumb->LoadFont("Data/sfd/FreeMono.ttf", 15);

    // Timer für Asteroiden zurücksetzen
    m_fAsteroidTimer = 0.0f;

    // Spiel läuft
    m_bGameRun = true;
} // Init

// Quit
//
// Aufgabe: Instanzen freigeben
//
void CGame::Quit ()
{
    // Spieler freigeben
    if (m_pPlayer != NULL)
    {
        m_pPlayer->Quit ();
        delete (m_pPlayer);
        m_pPlayer = NULL ;
    }

    /* Spieler freigeben
    if (m_pOpponent != NULL)
    {
        m_pOpponent->Quit ();
        delete (m_pOpponent);
        m_pOpponent = NULL ;
    }*/


    // Hintergrundsprite freigeben
    if (m_pSpriteBackground != NULL)
    {
        delete (m_pSpriteBackground);
        m_pSpriteBackground = NULL;
    }

    // Asteroidensprite freigeben
    if (m_pSpriteAsteroid != NULL)
    {
        delete (m_pSpriteAsteroid);
        m_pSpriteAsteroid = NULL;
    }

        // Explosionssprite freigeben
    if (m_pSpriteExplosion != NULL)
    {
        delete (m_pSpriteExplosion);
        m_pSpriteExplosion = NULL;
    }

    // Hintergrundmusik freigeben
    if (m_pMusic != NULL)
    {
        delete (m_pMusic);
        m_pMusic = NULL;
    }

    // Sound für Asteroiden-Explosion freigeben
    if (m_pSoundAsteroid != NULL)
    {
        delete (m_pSoundAsteroid);
        m_pSoundAsteroid = NULL;
    }

    // Lebensenergie freigeben
    if (m_pFontLive != NULL)
    {
        delete (m_pFontLive);
        m_pFontLive = NULL;
    }

    // Lebenspunkte freigeben
    if (m_pFontNumb != NULL)
    {
        delete (m_pFontNumb);
        m_pFontNumb = NULL;
    }


} // Quit

// Run
//
// Aufgabe: Hauptschleife des Spiels
//
void CGame::Run ()
{
    // Zerstörte Asteroiden (Anzahl)
    m_AsteroidDestroy = 0;

    // Hauptschleife des Spiels durchlaufen
    //
    while (m_bGameRun == true)
    {
        // Events bearbeiten
        ProcessEvents ();

        // Framework updaten und Buffer löschen
        g_pFramework->Update ();
        g_pFramework->Clear ();

        // Hintergrundbild rendern
        m_pSpriteBackground->Render ();

        // Spieler updaten und rendern
        m_pPlayer->Update ();
        m_pPlayer->Render ();
        
        // Gegner updaten und rendern
        //m_pOpponent->Update ();
        //m_pOpponent->Render ();

        // Lebensenergie anzeigen
        int m_HitCount = m_pPlayer->GetHealth();
        
        if (m_HitCount>=5)
        {       
            m_pFontNumb->WriteFont("Energie: ", 530, 550, 255, 20, 50);
            m_pFontNumb->WriteNumber(m_HitCount, 610, 550, 255, 20, 50);
        }
        else if (m_HitCount<=5)
        {
            m_pFontNumb->WriteFont("Energie: ", 530, 550, 255, 20, 50);
            m_pFontNumb->WriteFont("Kritischer Zustand", 610, 550, 255, 20, 50);
        }
            
        // Neue Asteroiden hinzufügen
        SpawnAsteroids ();

        // Kollisionen prüfen
        CheckCollisions ();

        // Asteroiden zerstört (Anzahl)
        if (m_AsteroidDestroy <= 20)
        {
            m_pFontLive->WriteFont("Asteroiden:", 10, 550, 255, 20, 50);
            m_pFontNumb->WriteNumber(m_AsteroidDestroy, 120, 550, 255, 20, 50);
        }
        else
        {
            m_pFontLive->WriteFont("Ziel erreicht!", 10, 550, 255, 20, 50);
        }       

        // Explosion rendern
        RenderExplosion ();
        
        // Asteroiden rendern
        RenderAsteroids ();

        // Buffer flippen
        g_pFramework->Flip ();
    }

} // Run

// ProcessEvents
//
// Aufgabe: Events bearbeiten
//
void CGame::ProcessEvents ()
{
    SDL_Event Event;

    // Gab es ein Event?
    if (SDL_PollEvent (&Event))
    {
        // Ja, also schauen welches
        switch (Event.type)
        {
            // Beenden?
        case (SDL_QUIT):
            {
                m_bGameRun = false;

            } break;


            // Wurde eine Taste gedrückt?
        case (SDL_KEYDOWN):
            {
                switch (Event.key.keysym.sym)
                {
                case (SDLK_ESCAPE):
                    {
                        // Ja, also Spiel beenden
                        m_bGameRun = false;

                    } break;
                }
            } break;
        }
    }

} // ProcessEvents

// SpawnAsteroids
//
// Aufgabe: Nach Ablauf einer bestimmten Zeit neuen Asteroiden erzeugen
//
void CGame::SpawnAsteroids ()
{
    // Timer für nächsten Asteroiden erhöhen
    m_fAsteroidTimer += g_pTimer->GetElapsed ();

    // Wenn eine halbe Sekunde vergangen ist,
    // dann einen neuen Asteroiden erzeugen
    if (m_fAsteroidTimer >= 0.5)
    {
        // Neuer Asteroid
        CAsteroid Asteroid;

        // Zufällige X-Position
        int XPos = rand()%736;

        // Asteroid initialisieren
        Asteroid.Init (m_pSpriteAsteroid, static_cast<float>(XPos), -60.0f);

        // Asteroid in Liste einfügen
        m_AsteroidList.push_back (Asteroid);

        // Zeitgeber wieder zurücksetzen
        m_fAsteroidTimer = 0.0f;
    }

} // SpawnAsteroids


// SpawnExplosion
//
// Aufgabe: Explosion nach einer Kollision erzeugen
//
void CGame::SpawnExplosion ()
{
        // Explosion hinzufügen
        CExplosion Explosion;
        // Asteroid initialisieren
        Explosion.Init (m_pSpriteExplosion, 300.0f, 300.f);

        // Asteroid in Liste einfügen
        m_ExplosionList.push_back (Explosion);          

} // SpawnExplosion

// CheckCollisions
//
// Aufgabe: Kollisionen zwischen Asteroiden und Schüssen prüfen
//
void CGame::CheckCollisions ()
{
    // Schussliste des Spielers holen
    list<CShot> *ShotList = m_pPlayer->GetShotList ();

    // Iteratoren für Asteroiden- und Schussliste sowie Explosionsliste
    list<CAsteroid>::iterator ItAsteroid = m_AsteroidList.begin ();
    list<CShot>::iterator ItShot;
    list<CExplosion>::iterator ItExplosion = m_ExplosionList.begin ();

    // Rects für Asteroiden und Schüsse sowie Spieler
    SDL_Rect RectAsteroid;
    SDL_Rect RectShot;
    SDL_Rect RectPlayer;
    

    // Alle Asteroiden durchlaufen
    while (ItAsteroid != m_AsteroidList.end () )
    {
        // Rect des Asteroiden holen
        RectAsteroid = ItAsteroid->GetRect ();

        // Rect des Spielers holen (Erweitert)
        RectPlayer = m_pPlayer->GetRect();

        // Alle Schüsse durchlaufen
        for (ItShot = ShotList->begin ();
            ItShot != ShotList->end ();
            ++ItShot)
        {
            // Rect des Schusses holen
            RectShot = ItShot->GetRect ();

            // Überschneiden sich die Rects?
            if (RectShot.y < RectAsteroid.y + RectAsteroid.h &&
                RectShot.y + RectShot.h > RectAsteroid.y &&
                RectShot.x < RectAsteroid.x + RectAsteroid.w &&
                RectShot.x + RectShot.w > RectAsteroid.x)
            {       
                // Ja, also gab es eine Kollision. Somit Schuss und
                // Asteroid deaktivieren
                ItAsteroid->SetAlive (false);
                ItShot->SetAlive (false);
                m_AsteroidDestroy++;            // Wieviele Asteroiden zerstört?
                m_pSoundAsteroid->PlaySound();  // Asteriod explodiert -> Soundeffekt   

                SpawnExplosion ();              // Explosion erstellen und in Liste schieben
                
            }

        }

        // Kollision zwischen Asteroid und Spieler prüfen          
            if (RectPlayer.y < RectAsteroid.y + RectAsteroid.h &&
                RectPlayer.y + RectPlayer.h > RectAsteroid.y &&
                RectPlayer.x < RectAsteroid.x + RectAsteroid.w &&
                RectPlayer.x + RectPlayer.w > RectAsteroid.x)
            {
                // Ja, also gab es eine Kollision. Somit Spieler und
                // Asteroid deaktivieren
                ItAsteroid->SetAlive (false);
                m_pPlayer->SetHealth();
                m_pPlayer->Reset();
                // Asteriod explodiert -> Soundeffekt
                m_pSoundAsteroid->PlaySound();
                            
            }

        // Asteroid löschen, falls deaktiviert
        if (ItAsteroid->IsAlive () )
            ItAsteroid++;
        else
            ItAsteroid = m_AsteroidList.erase (ItAsteroid);
        
    }

} // CheckCollision

// RenderAsteroids
//
// Aufgabe: Alle Asteroiden rendern und updaten
//
void CGame::RenderAsteroids ()
{
    // Iterator für die Asteroiden-Liste
    list<CAsteroid>::iterator It;

    // Asteroiden-Liste durchlaufen
    for (It = m_AsteroidList.begin (); It != m_AsteroidList.end (); ++It)
    {
        // Asteroid rendern
        It->Render ();

        // Asteroid updaten
        It->Update ();

    }

} // RenderAsteroids

// RenderAsteroids
//
// Aufgabe: Alle Explosion rendern und updaten
//
void CGame::RenderExplosion ()
{
    // Iterator für die Explosion-Liste
    list<CExplosion>::iterator It;

    // Explosion-Liste durchlaufen
    for (It = m_ExplosionList.begin (); It != m_ExplosionList.end (); ++It)
    {
        // Explosion rendern
        It->Render ();

        // Explosion updaten
        It->Update ();

    }

} // RenderExplosion