spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#ifndef EXPLOSION_HPP
#define EXPLOSION_HPP

#include "Sprite.hpp"

class CExplosion
{
  public:
    void Init     (CSprite *pSpriteExplosion, float fXPos, float fYPos);
    void Update   ();
    void Render   ();
    bool IsAlive  () {return m_bIsAlive;}
    void SetAlive (bool bIsAlive) {m_bIsAlive = bIsAlive;}
    SDL_Rect GetRect () {return m_Rect;}

  private:
    CSprite *m_pSpriteExplosion; // Zeiger auf Explosion-Sprite

    float    m_fXPos;           // X-Position der Explosion

    float    m_fYPos;           // Y-Position der Explosion

    float    m_fAnimPhase;      // Akt. Animationsphase des Asteroiden

    bool     m_bIsAlive;        // "Lebt" die Explosion noch?

    SDL_Rect m_Rect;            // Rect des Explosion


};

#endif

#include "Explosion.hpp"

// Init

//

// Aufgabe: Explosion initialisieren

//

void CExplosion::Init (CSprite *pSpriteExplosion, float fXPos, float fYPos)
{
  // Zeiger auf Sprite kopieren und Koordinaten setzen

  m_pSpriteExplosion = pSpriteExplosion;
  m_fXPos = fXPos;
  m_fYPos = fYPos;

  // Animation beginnt beim ersten Einzelbild

  m_fAnimPhase = 0.0f;

  // Rect initialisieren

  m_Rect.x = static_cast<int>(fXPos);
  m_Rect.y = static_cast<int>(fYPos);
  m_Rect.w = pSpriteExplosion->GetRect().w;
  m_Rect.h = pSpriteExplosion->GetRect().h;

  // Exlosion aktivieren

  m_bIsAlive = true;

} // Init



// Update

//

// Aufgabe: Exlosion bewegen und Position prüfen

//

void CExplosion::Update ()
{
  // Explosion bewegen

  m_fYPos += 12.0f * g_pTimer->GetElapsed ();

  m_Rect.y = static_cast<int>(m_fYPos);

// Animieren

  m_fAnimPhase += 10.0f * g_pTimer->GetElapsed ();

  // Prüfen, ob die Animation am Ende angelangt ist

  if (m_fAnimPhase >= 10.0f )
  {
        m_bIsAlive = false;
  } 


} // Update



// Render

//

// Aufgabe: Explosion rendern

//

void CExplosion::Render ()
{
  m_pSpriteExplosion->SetPos (m_fXPos, m_fYPos);
  m_pSpriteExplosion->Render (m_fAnimPhase);

} // Render


#ifndef GAME_HPP
#define GAME_HPP

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

class CGame
{
  public:
    CGame ();

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

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

    CPlayer *m_pPlayer;             // Spieler-Instanz

    CSprite *m_pSpriteBackground;   // Sprite für den Hintergrund

    CSprite *m_pSpriteAsteroid;     // Sprite für die Asteroiden

    CSprite *m_pSpriteExplosion;    //Sprite für eine Explosion

    float    m_fAsteroidTimer;      // Zeitgeber für nächsten Asteroiden

    bool     m_bGameRun;            // Läuft das Spiel noch?

    list<CAsteroid> m_AsteroidList; // Liste der Asteroiden

    list<CExplosion> m_ExplosionList; 

};

#endif


#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  Asteroid und Explosion 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);
  m_pSpriteAsteroid->SetColorKey (255, 0, 255);
  
  // Sprite für Explosion laden

  m_pSpriteExplosion = new CSprite; 
  m_pSpriteExplosion->Load ("Data/Explosion2.bmp", 10, 70, 70); 
  m_pSpriteExplosion->SetColorKey (255, 0, 255); 

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

    // Neue Exlosion hinzufügen

    

    // Kollisionen prüfen

    CheckCollisions ();

    // Asteroiden rendern

    RenderAsteroids ();

    // Explosion redern

    RenderExplosion ();


    
    // 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.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<CExplosion>::iterator ItExplosion = m_ExplosionList.begin ();
  list<CShot>::iterator ItShot;
  // Rects für Asteroiden und Schüsse

  SDL_Rect RectAsteroid;
  SDL_Rect RectExplosion;
  SDL_Rect RectShot;
  SDL_Rect RectPlayer;

  // Alle Asteroiden durchlaufen

  while (ItAsteroid != m_AsteroidList.end () )
  {
    // Rect des Asteroiden und der Explosion holen

    RectAsteroid = ItAsteroid->GetRect ();

    // Rect des Spielers holen

    RectPlayer = m_pPlayer->GetRect();

    

      

// Kollision zwischen Spieler und Asteroid 

      if (RectPlayer.y < RectAsteroid.y + RectAsteroid.h && 
          RectPlayer.y + RectPlayer.h > RectAsteroid.y && 
          RectPlayer.x < RectAsteroid.x + RectAsteroid.w && 
          RectPlayer.x + 64 > RectAsteroid.x) 
      { 
        // Ja, also gab es eine Kollision. 

    //Asteroid löschen, Spieler zurücksetzen 

        ItAsteroid->SetAlive (false); 
        m_pPlayer->Reset(); 
      }
        // 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);

// Rect der Exlosion holen

    RectExplosion = ItExplosion->GetRect();

/*      CExplosion Bumm; 
Bumm.Init (m_pSpriteExplosion, RectAsteroid.x, RectAsteroid.y);
Bumm.Update(); 
Bumm.Render(); */ ???????



      }
    
    }

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

  }

} // RenderExplosion


// RenderExlosion

//

// Aufgabe: Alle Explosionen rendern und updaten

//

void CGame::RenderExplosion ()
{
  // Iterator für die Asteroiden-Liste

  list<CExplosion>::iterator It;

  // Asteroiden-Liste durchlaufen

  for (It = m_ExplosionList.begin (); It != m_ExplosionList.end (); ++It)
  {
    // Asteroid rendern

    It->Render ();

    // Asteroid updaten

    It->Update ();

  }

} // RenderExlosion

C-/C++-Quelltext

#ifndef SPRITE_HPP
#define SPRITE_HPP

#include "Framework.hpp"

class CSprite
{
  public:
    CSprite ();
    ~CSprite ();

    void Load        (const string sFilename);
    void Load        (const string sFilename, int NumFrames,
                      int FrameWidth, int FrameHeight);
    void SetColorKey (int R, int G, int B);
    void SetPos      (float fXPos, float fYPos);
    void Render      ();
    void Render      (float fFrameNumber);
    SDL_Rect GetRect () {return m_Rect;}

  private:
    SDL_Surface *m_pScreen; // Zeiger auf den Screen des Frameworks

    SDL_Surface *m_pImage;  // Das eigentliche Bild des Sprites

    SDL_Rect m_Rect;        // Rect des Sprites

    SDL_Rect m_FrameRect;   // Ausschnitt für Animationsphase

    int m_NumFrames;        // Anzahl der Animationsphasen

    int m_FrameWidth;       // Breite einer Animationsphase

    int m_FrameHeight;      // Höhe einer Animationsphase

    int m_NumFramesX;       // Wie viele Anim-Phasen in X-Richtung?


};

#endif


#include "Sprite.hpp"

// Konstruktor

//

// Aufgabe: Zeiger auf Screen holen

//

CSprite::CSprite ()
{
  // Zeiger auf Screen holen

  m_pScreen = g_pFramework->GetScreen ();

} // Konstruktor



// Destruktor

//

// Aufgabe: Surface des Sprites freigeben

//

CSprite::~CSprite ()
{
  // Surface freigeben

  SDL_FreeSurface (m_pImage);

} // Destruktor



// Load

//

// Aufgabe: Einfaches, nicht animiertes Sprite laden

//

void CSprite::Load (const string sFilename)
{
  // Bitmap laden

  m_pImage = SDL_LoadBMP (sFilename.c_str () );

  // Prüfen, ob alles glatt ging

  if (m_pImage == NULL)
  {
    cout << "Fehler beim Laden von: " << sFilename.c_str ();
    cout << endl;
    cout << "Fehlermeldung: " << SDL_GetError () << endl;

    // Framework herunterfahren

    g_pFramework->Quit ();

    // Gesamtes Spiel beenden

    exit (1);
  }

  // Rect initialisieren

  m_Rect.x = 0;
  m_Rect.y = 0;
  m_Rect.w = m_pImage->w;
  m_Rect.h = m_pImage->h;

} // Load



// Load

//

// Aufgabe: Animiertes Sprite laden

//

void CSprite::Load (const string sFilename, int NumFrames,
                    int FrameWidth, int FrameHeight)
{
  // Bitmap laden

  Load (sFilename); 

  // Rect für Animationsphase initialisieren

  m_NumFrames   = NumFrames;
  m_FrameWidth  = FrameWidth;
  m_FrameHeight = FrameHeight;
  m_FrameRect.w = FrameWidth;
  m_FrameRect.h = FrameHeight;
  m_NumFramesX  = m_pImage->w / m_FrameWidth;

} // Load



// SetColorKey

//

// Aufgabe: Transparente Farbe festlegen

//

void CSprite::SetColorKey (int R, int G, int B)
{
  // Colorkey einstellen

  SDL_SetColorKey (m_pImage, SDL_SRCCOLORKEY, 
                   SDL_MapRGB (m_pImage->format, R, G, B) );

} // SetColorKey



// SetPos

//

// Aufgabe: Position des Sprites festlegen

//

void CSprite::SetPos (float fXPos, float fYPos)
{
  // Rect updaten

  m_Rect.x = static_cast<int>(fXPos);
  m_Rect.y = static_cast<int>(fYPos);

} // SetPos



// Render

//

// Aufgabe: Sprite rendern (ohne Animation)

//

void CSprite::Render ()
{
  // Sprite rendern

  SDL_BlitSurface (m_pImage, NULL, m_pScreen, &m_Rect);

} // Render



// Render

//

// Aufgabe: Ausschnitt des Sprites rendern (Animationsphase)

//

void CSprite::Render (float fFrameNumber)
{
  // Ausschnitt der aktuellen Animationsphase berechnen

  //


  // Spalte berechnen

  int Column = static_cast<int>(fFrameNumber)%m_NumFramesX;

  // Zeile berechnen

  int Row = static_cast<int>(fFrameNumber)/m_NumFramesX;

  // Rect berechnen

  m_FrameRect.x = Column * m_FrameWidth;
  m_FrameRect.y = Row * m_FrameHeight;

  // Ausschnitt rendern

  SDL_BlitSurface (m_pImage, &m_FrameRect, m_pScreen, &m_Rect);

} // Render