spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

        SDL_Rect GetRect () {return m_Rect;}

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

C-/C++-Quelltext

#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

C-/C++-Quelltext

void Player::Init ()
{

m_Rect.x = static_cast<int>(m_fXPos);
m_Rect.y = static_cast<int>(m_fYPos);
m_Rect.w = m_pSpritePlayer->GetRect ().w;
m_Rect.h = m_pSpritePlayer->GetRect ().h;


m_pSpritePlayer = new CSprite;
m_pSpritePlayer->Load ("Data/Schläger.jpg");
m_pSpritePlayer->SetColorKey (255, 0, 255);
}

C-/C++-Quelltext

#include "Sprite.hpp"




class Player
{

public:
Player ();
void Init ();
void Quit ();
void Render ();
void Update ();
void Reset ();
SDL_Rect GetRect () {return m_Rect;}

private:
void Move ();
void Position ();
CSprite *m_pSpritePlayer;
float m_fXPos;
float m_fYPos;
SDL_Rect m_Rect;

};

C-/C++-Quelltext

void Ball::Init (CSprite *pSpriteBall, float fXPos, float fYPos)
{
    m_pSpriteBall = pSpriteBall;
    m_fXPos = fXPos;
    m_fYPos = fYPos;



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

    m_bIsAlive = true;
}