spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include "Sprite.hpp"
// Konstruktor
//
// Aufgabe: Zeiger auf Screen holen
//
CSprite::CSprite ()
{
    // Zeiger auf Screen holen (Wir merken uns den Zeiger, damit nicht bei jedem Rendervorgang auf Framework zugegriffen werden soll)
    m_pScreen = g_pFramework->GetScreen (); // Zeiger auf Screen des Frameworks holen, auf den gerendert werden soll
                                            // Da kein Objekt, sondern Zeiger -> keine freigabe!

} // Konstruktor

// Destruktor
//
// Aufgabe: Surface des Sprites freigeben
//
CSprite::~CSprite ()
{
    // Surface freigeben
    SDL_FreeSurface (m_pImage);     // Bei Framework kümmert sich SDL um Freigabe der Surface m_pScreen
                                    // bei Surface für Sprite muss dies über Funktion "SDL_FreeSurface" geschehen!

} // Destruktor

// Load
//
// Aufgabe: Einfaches, nicht animiertes Sprite laden
//
void CSprite::Load (const string sFilename)
{
    // Bitmap laden
    m_pImage = SDL_LoadBMP (sFilename.c_str () );   // SDL_LoadBMP gibt Zeiger zurück! Daher keine Speicherreservierung ala "new" für m_pImage 

    // 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 (Position)
    m_Rect.x = 0;           // Koodinaten für Position von Sprites (Sind relativ zur linken oberen Ecke des Bildschirms)
    m_Rect.y = 0;           // z.B. Hintergrundbild
    //Breite und Höhe über m_pImage ermitteln (Größe), da Zeiger auf eigentlichen BMP zeigt
    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 über Funktion "Load (const string sFilename)"
    Load (sFilename);

    // Rect für Animationsphase initialisieren
    m_NumFrames   = NumFrames;                      // Anzahl an Frames (Gesamt)
    m_FrameWidth  = FrameWidth;                     // werden beim Rendern als Zwischen-Membervariablen für die Berechnung verwendet
    m_FrameHeight = FrameHeight;
    m_FrameRect.w = FrameWidth;                     // Breite und Höhe einer einzelnen Animationsphase in m_FrameRec speichern 
    m_FrameRect.h = FrameHeight;                    // Diese Werte ändern sich nicht mehr
    m_NumFramesX  = m_pImage->w / m_FrameWidth;     // Anzahl an Frames in X-Richtung ermitteln

} // 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 auf dem Bildschirm festlegen
//
void CSprite::SetPos (int fXPos, int fYPos)
{
    // Rect updaten
    m_Rect.x = fXPos;       // m_FrameRect bleibt davon unberührt, da diese Membervariable
                                            // nur für Ausschnitte der aktuellen Animationsphase verantwortlich ist
    m_Rect.y = fYPos;

} // SetPos

// Render
//
// Aufgabe: Sprite rendern (ohne Animation)
//
void CSprite::Render ()
{
    // Sprite rendern 
    // Sprite (oder bei animierte Sprite nur ein Auschnitt) wird in Back-buffer (Buffer, der gerade nicht sichtbar ist, also m_pScreen) kopiert,
    // SDL_Flip übernimmt dann Wechsel zwischen den Buffern, damit es nicht flimmert. 
    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;   // Animationsphase 7 hat den Wert fFrameNumber = 6. Rechnung: 6%AnzahlFramesproZeile = 2(Ganzzahliger Rest)

    // Zeile berechnen
    int Row = static_cast<int>(fFrameNumber)/m_NumFramesX;      // z.B. 6/4=1,5 -> Casting in int liefert 1 -> 1 Zeile

    // Rect berechnen (Position, an der sich die gewünschte Animationsphase befindet)
    m_FrameRect.x = Column * m_FrameWidth;
    m_FrameRect.y = Row * m_FrameHeight;

    // Ausschnitt rendern (also in den Back-buffer kopieren)
    SDL_BlitSurface (m_pImage, &m_FrameRect, m_pScreen, &m_Rect);

} // Render