spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#ifndef DARKPOULDER_HPP
#define DARKPOULDER_HPP
#include"Shot.hpp"

class DPoulder :  public CShot
{

public:
    void ExplodeInit(CSprite *Explo);
    void RenderExplode(int Ani);
    void UpdateExplode();
    bool ExIsAlive(bool alive){SetAlive (alive);}
private:
    CSprite *m_Explode;
    float Anim;


};
#endif // DARKPOULDER_HPP

C-/C++-Quelltext

#include"DarkPoulder.hpp"
#include<iostream>
using namespace std;

void DPoulder::ExplodeInit(CSprite *Explo)
{
   m_Explode=Explo;
   Anim=0.0f;
}
void DPoulder::RenderExplode(int Ani)
{

   m_Explode->SetPos(GetX(),GetY()); //<-- Hier stürzt er anscheinend ab, auch wie in der Zeile darunter.
   m_Explode->Render(Ani);

}
void DPoulder::UpdateExplode()
{                      


    Anim+=10*g_pTimer->GetElapsed();
    RenderExplode(Anim);

}

C-/C++-Quelltext

#ifndef SHOT_HPP
#define SHOT_HPP

#include "../../LXMRox/Sprite/Includes/Sprite.hpp"

class CShot
{
  public:
      virtual ~CShot();
    void Init     (CSprite *pSpriteShot, float fXPos, float fYPos);
    void Update   ();
    void Render   ();
    bool IsAlive  () {return m_bIsAlive;}
    void SetAlive (bool bIsAlive) {m_bIsAlive = bIsAlive;}
    void SetIsFly(){m_bIsFly=false;}
    SDL_Rect GetRect () {return m_Rect;}
    bool GetIsFly(){return m_bIsFly;}
    float GetX(){return m_fXPos;}
    float GetY(){return m_fYPos;}
float    m_fXPos;       // X-Position des Schusses
    float    m_fYPos;       // Y-Position des Schusses
  private:
    CSprite *m_pSpriteShot; // Zeiger auf Laser-Sprite

    bool     m_bIsFly;
    bool     m_bIsAlive;    // "Lebt" der Schuss noch?
    SDL_Rect m_Rect;        // Rect des Schusses
};

#endif

C-/C++-Quelltext

#include "Shot.hpp"
CShot::~CShot()
{

}

// Init
//
// Aufgabe: Schuss initialisieren
//
void CShot::Init (CSprite *pSpriteShot, float fXPos, float fYPos)
{

  // Zeiger auf Sprite kopieren und Koordinaten setzen
  m_pSpriteShot = pSpriteShot;
  m_fXPos = fXPos;
  m_fYPos = fYPos;

  // Rect initialisieren
  m_Rect.x = static_cast<int>(fXPos);
  m_Rect.y = static_cast<int>(fYPos);
  m_Rect.w = pSpriteShot->GetRect().w;
  m_Rect.h = pSpriteShot->GetRect().h;
  m_bIsFly=true;
  // Schuss aktivieren
  m_bIsAlive = true;

} // Init


// Update
//
// Aufgabe: Schuss bewegen und Position prüfen
//
void CShot::Update ()
{

    if(m_bIsFly==true)
    {
      // Schuss bewegen
        m_fYPos -= 400.0f * g_pTimer->GetElapsed ();

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

  // Deaktivieren, falls außerhalb des Bildschirms
        if (m_fYPos < -15.0f)
            m_bIsAlive = false;
    }

} // Update


// Render
//
// Aufgabe: Schuss rendern
//
void CShot::Render ()
{

  if ( m_bIsFly== true)
  {
    // Koordinaten setzen und rendern
    m_pSpriteShot->SetPos (m_fXPos, m_fYPos);
    m_pSpriteShot->Render ();
  }


} // Render

C-/C++-Quelltext

  // Wurde Space gedrückt und darf geschossen werden?
  if (g_pFramework->KeyDown (SDLK_SPACE) && m_bShotLock == false)
  {
    // Neuen Schuss erzeugen und initialisieren

    DPoulder Hannel;


    Hannel.Init (m_pSpriteShot, m_fXPos, m_fYPos);
    Hannel.ExplodeInit(m_pExplode);

    // Schuss in Liste einfügen
    m_ShotList.push_back (Hannel);

    // Schießen erst wieder erlaubt, wenn Space losgelassen
    m_bShotLock = true;

  }

  // Ist die Leertaste nicht mehr gedrückt, schießen wieder erlaubt
  if (g_pFramework->KeyDown (SDLK_SPACE) == false)
    m_bShotLock = false;

C-/C++-Quelltext

#include "Player.hpp"
#include<iostream>
using namespace std;

// Konstruktor
//
// Aufgabe: Allgemeine Initialisierungen
//
CPlayer::CPlayer ()
{
  m_pSpritePlayer = NULL;
  m_pSpriteShot = NULL;

} // Konstruktor


// Init
//
// Aufgabe: Sprites erzeugen und laden
//
void CPlayer::Init ()
{
  // Spielersprite erstellen
  m_pSpritePlayer = new CSprite;

  m_pSpritePlayer->Load ("../Data/Game/Player.bmp", 11, 64,64,"Player");
  m_pSpritePlayer->SetColorKey (255, 0, 255);

  // Schuss-Sprite erstellen
  m_pSpriteShot = new CSprite;

  m_pSpriteShot->Load ("../Data/Game/Laser.bmp", 0, 64, 64,"Schuesse");
  m_pSpriteShot->SetColorKey (255, 0, 255);

  m_pExplode=new CSprite;
  m_pExplode->LoadPNG("../Data/Game/ExplodeBlue.png", 4, 72, 72,"BlueExplode");


} // Init


// Quit
//
// Aufgabe: Sprites freigeben
//
void CPlayer::Quit ()
{
  // Spieler-Sprite freigeben
  if (m_pSpritePlayer != NULL)
  {
    delete (m_pSpritePlayer);
    m_pSpritePlayer = NULL;
  }

  // Schuss-Sprite freigeben
  if (m_pSpritePlayer != NULL)
  {
    delete (m_pSpritePlayer);
    m_pSpritePlayer = NULL;
  }
  if(m_pExplode!=0)
  {
      delete(m_pExplode);
      m_pExplode=NULL;
  }

} // Quit


// Reset
//
// Aufgabe: Spielerwerte auf Standard setzen
//
void CPlayer::Reset ()
{
  // Startposition des Spielers
  m_fXPos = 376.0f;
  m_fYPos = 604.0f;

  // Animationsphase
  m_fAnimPhase = 5.0f;

  // Es darf geschossen werden
  m_bShotLock = false;

} // Reset


// Render
//
// Aufgabe: Spieler und Schüsse rendern
//
void CPlayer::Render ()
{

  // Position des Spielers setzen und Sprite rendern
  m_pSpritePlayer->SetPos (m_fXPos, m_fYPos);
  m_pSpritePlayer->Render (m_fAnimPhase);

  // Iterator für Schussliste
  list<DPoulder>::iterator it = m_ShotList.begin ();

  // Schussliste durchlaufen
  while (it != m_ShotList.end ())
  {


    // Ist der Schuss noch aktiv?
    if (it->GetIsFly())
    {
         // Schuss updaten
        it->Update ();
      // Ja, dann rendern
      it->Render ();
      it++;
    }

   if(it->GetIsFly()==false)
   {

      it->UpdateExplode();

   }

  }


} // Render


// Update
//
// Aufgabe: Spieler updaten
//
void CPlayer::Update ()
{
  // Bewegung des Spielers
  ProcessMoving ();

  // Prüfen, ob geschossen wurde
  ProcessShooting ();

  // Position und Animationsphase überprüfen
  CheckPosition ();

} // Update


// ProcessMoving
//
// Aufgabe: Bewegung des Spielers
//
void CPlayer::ProcessMoving ()
{
  // Nach links?
  if (g_pFramework->KeyDown (SDLK_LEFT))
  {
    // Spieler nach links bewegen
    m_fXPos -= 300.0f * g_pTimer->GetElapsed ();

    // Animieren
    m_fAnimPhase -= 20.0f * g_pTimer->GetElapsed ();

  }
  // Nach rechts?
  else if (g_pFramework->KeyDown (SDLK_RIGHT))
  {
    // Spieler nach rechts bewegen
    m_fXPos += 300.0f * g_pTimer->GetElapsed ();

    // Animieren
    m_fAnimPhase += 20.0f * g_pTimer->GetElapsed ();

  }
  // Spieler wurde nicht bewegt
  else
  {
    // Animation zurück zum Ausgangspunkt
    if (m_fAnimPhase > 5.0f)
      m_fAnimPhase -= 20.0f * g_pTimer->GetElapsed ();

    if (m_fAnimPhase < 5.0f)
      m_fAnimPhase += 20.0f * g_pTimer->GetElapsed ();
  }

} // ProcessMoving


// ProcessShooting
//
// Aufgabe: Waffe abfeuern
//
void CPlayer::ProcessShooting ()
{

  // Wurde Space gedrückt und darf geschossen werden?
  if (g_pFramework->KeyDown (SDLK_SPACE) && m_bShotLock == false)
  {
    // Neuen Schuss erzeugen und initialisieren

    DPoulder Hannel;


    Hannel.Init (m_pSpriteShot, m_fXPos, m_fYPos);
    Hannel.ExplodeInit(m_pExplode);

    // Schuss in Liste einfügen
    m_ShotList.push_back (Hannel);

    // Schießen erst wieder erlaubt, wenn Space losgelassen
    m_bShotLock = true;

  }

  // Ist die Leertaste nicht mehr gedrückt, schießen wieder erlaubt
  if (g_pFramework->KeyDown (SDLK_SPACE) == false)
    m_bShotLock = false;

} // ProcessShooting


// CheckPosition
//
// Aufgabe: Position und Animationsphase prüfen
//
void CPlayer::CheckPosition ()
{
  // Linker und rechter Rand
  if (m_fXPos < 0.0f)
    m_fXPos = 0.0f;
  else if (m_fXPos > 752.0f)
    m_fXPos = 752.0f;

  // Animationsphase prüfen
  if (m_fAnimPhase < 0.0f)
    m_fAnimPhase = 0.0f;
  else if (m_fAnimPhase > 10.0f)
    m_fAnimPhase = 10.0f;

} // CheckPosition