spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#ifndef GAME_HPP
#define GAME_HPP

#include "Player.hpp"
#include "Asteroid.hpp"

class CGame
{
    public:
        CGame ();

        void Init ();
        void Run  ();
        void Quit ();

    private:
        void ProcessEvents   ();
        void SpawnAsteroids  ();
        void RenderAsteroids ();
        void CheckCollisions ();

        CPlayer *m_pPlayer;             // Spieler-Instanz
        CSprite *m_pSpriteBackground;   // Sprite fόr den Hintergrund
        CSprite *m_pSpriteAsteroid;     // Sprite fόr die Asteroiden
        float    m_fAsteroidTimer;      // Zeitgeber fόr nδchsten Asteroiden
        bool     m_bGameRun;            // Lδuft das Spiel noch?
        list<CAsteroid> m_AsteroidList; // Liste der Asteroiden

};

#endif

C-/C++-Quelltext

#include "Game.hpp"

// Konstruktor
//
// Aufgabe: Allgemeine Initialisierungen
//
CGame::CGame ()
{
    m_pPlayer = NULL;
    m_pSpriteBackground = NULL;
    m_pSpriteAsteroid = 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 ();

    // 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);
    
    // 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 ;
    }

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

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

} // Quit


// Run
//
// Aufgabe: Hauptschleife des Spiels
//
void CGame::Run ()
{
    // 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 ();

        // Neue Asteroiden hinzufόgen
        SpawnAsteroids ();

        // Kollisionen prόfen
        CheckCollisions ();

        // Asteroiden rendern
        RenderAsteroids ();

        // Spiel darstellen
        g_pFramework->Render ();

    }

} // 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;
                        
                    default:
                        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,
    // einen neuen Asteroiden erzeugen
    if (m_fAsteroidTimer >= 0.5f)
    {
        // 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


// 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
    list<CAsteroid>::iterator ItAsteroid = m_AsteroidList.begin ();
    list<CShot>::iterator ItShot;

    // Rects fόr Asteroiden und Schόsse
    SDL_Rect RectAsteroid;
    SDL_Rect RectShot;

    // Alle Asteroiden durchlaufen
    while (ItAsteroid != m_AsteroidList.end () )
    {
        // Rect des Asteroiden holen
        RectAsteroid = ItAsteroid->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);
            }
        }

        // 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

C-/C++-Quelltext

CGame::Run ()
{
    while (m_bRun)
    {
        Update ();
        Render ();
    }
}

CGame::Update ()
{
    PumpEvents ();

    int Result = 0; // Temporaere Variable um die State zu kontrollieren
            

    switch (state)
    {
        case (Menu):
        {
            Result = m_pMenu->Update ();

            if (Result == 1) state = Level;
            if (Result == 2) state = Highscore;
            if (Result == -1) state = End;
        } break;

        case (Level):
        {
            Result = m_pLevel->Update ();

            if (Result == 1) state = Highscore;
            if (Result == -1) state = End;
        } break;

        case (Highscore):
        {
            Result = m_pHighscore->Update ();

            if (Result == -1) state = End;
        } break;

        case (End)
        {
            m_bRun = false;
        } break;

        case (default):
        {
            cout << "Fehler bei States" << endl;
        }
    }
}

CGame::Render ()
{
    g_pFramework->Clear ();
    g_pFramework->Update ();

    switch (State)
    {
        case (Menu):
        {
            m_pMenu->Render ();
        } break;

        case (Level)
        {
            m_pLevel->Render ();
        } break;

        case (Highscore):
        {
            m_pHighscore->Render ();
        } break;

        case (default):
        {
            cout << "Fehler bei States" << endl;
        }
    }

    g_pFramework->Render ();

}