spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include "Satellit.hpp"

// Init

//

// Aufgabe: Asteroid initialisieren

//

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

  m_pSpriteSatellit = pSpriteSatellit;
  m_fXPos_Satellit = fXPos;
  m_fYPos_Satellit = fYPos;

  // Animation beginnt beim ersten Einzelbild

  m_fAnimPhase_Satellit = 0.0f;

  // Rect initialisieren

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

  // Asteroid aktivieren

  m_bIsAlive = true;

} // Init



// Update

//

// Aufgabe: Asteroid bewegen und Position prüfen

//

void CSatellit::Update ()
{
  // Asteroid bewegen

  m_fYPos_Satellit += 200.0f * g_pTimer->GetElapsed ();

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

  // Animieren

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

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

  if (m_fAnimPhase_Satellit >= 20.0f)
    m_fAnimPhase_Satellit = m_fAnimPhase_Satellit - 20.0f;

  // Deaktivieren, falls außerhalb des Bildschirms

  if (m_fYPos_Satellit > 590.0f)
    m_bIsAlive = false;

} // Update



// Render

//

// Aufgabe: Asteroid rendern

//

void CSatellit::Render ()
{
  m_pSpriteSatellit->SetPos (m_fXPos_Satellit, m_fYPos_Satellit);
  m_pSpriteSatellit->Render (m_fAnimPhase_Satellit);

} // Render

C-/C++-Quelltext

#ifndef SATELLIT_HPP
#define SATELLIT_HPP

#include "Sprite.hpp"

class CSatellit
{
  public:
    void Init     (CSprite *pSpriteSatellit, 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_pSpriteSatellit;         // Zeiger auf Asteroiden-Sprite

    float    m_fXPos_Satellit;          // X-Position des Asteroiden

    float    m_fYPos_Satellit;          // Y-Position des Asteroiden

    float    m_fAnimPhase_Satellit;     // Akt. Animationsphase des Asteroiden

    bool     m_bIsAlive;       // "Lebt" der Asteroid noch?

    SDL_Rect m_Rect;                    // Rect des Satelliten


};

#endif

C-/C++-Quelltext

#ifndef GAME_HPP
#define GAME_HPP

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

class CGame
{
  public:
    CGame ();

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

  private:
    void ProcessEvents   ();
    void SpawnAsteroids  ();
    void SpawnSatellit   ();
    void RenderAsteroids ();
    void RenderSatellit  ();
    void CheckCollisions  ();
    void CheckCollisions_Satellit();

    CPlayer *m_pPlayer;             // Spieler-Instanz

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

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

    CSprite *m_pSpriteSatellit;     // Sprite für die Satelliten

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

    float    m_fSatellitTimer;      // Zeitgeber für nächsten Satelliten

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

    list<CAsteroid> m_AsteroidList; // Liste der Asteroiden

    list<CSatellit> m_SatellitList; // Liste der Satelliten


};

#endif

C-/C++-Quelltext

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

    // Kollisionen prüfen

    CheckCollisions ();

    // Asteroiden rendern

    RenderAsteroids ();
    RenderSatellit  ();

    // Buffer flippen

    g_pFramework->Flip ();

  }

} // Run

C-/C++-Quelltext

void CGame::SpawnSatellit ()
{
  // Timer für nächsten Asteroiden erhöhen

  m_fSatellitTimer += g_pTimer->GetElapsed ();

  // Wenn eine halbe Sekunde vergangen ist,

  // dann einen neuen Asteroiden erzeugen

  if (m_fSatellitTimer >= 1.0f)
  {
    // Neuer Asteroid

    CSatellit Satellit;

    // Zufällige X-Position

    int XPos_Satellit = rand()%736;

    // Asteroid initialisieren

    Satellit.Init (m_pSpriteSatellit, static_cast<float>(XPos_Satellit), -60.0f);

    // Asteroid in Liste einfügen

    m_SatellitList.push_back (Satellit);

    // Zeitgeber wieder zurücksetzen

    m_fSatellitTimer = 0.0f;

  }

} // SpawnAsteroids

C-/C++-Quelltext

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

  list<CSatellit>::iterator It;

  // Asteroiden-Liste durchlaufen

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

    It->Render ();

    // Asteroid updaten

    It->Update ();

  }

} // RenderSatellit

C-/C++-Quelltext

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

  // Timer für Asteroiden zurücksetzen

  m_fAsteroidTimer = 0.0f;


  // Sprite für Satelliten laden

  m_pSpriteSatellit = new CSprite;
  m_pSpriteSatellit->Load ("Data/Satellit.bmp", 1, 64, 64);
  m_pSpriteSatellit->SetColorKey (255,0,255);

  //Timer für Asteroiden zurücksetzen

  m_fSatellitTimer = 0.0f;

  // Spiel läuft

  m_bGameRun = true;

} // Init