spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

    list<CSprite> m_SpriteList;
    CSprite Keks;
    Keks.Load("Data/Keks.bmp");
    Keks.SetColorKey(255, 0, 255);
    Keks.SetPos(220, 0);
    m_SpriteList.push_back (Keks);

    list<CSprite>::iterator it = m_SpriteList.begin();

    while (it != m_SpriteList.end ())
    {
        // Einzelne Bilder Rendern
        it->Render();
        it++;
    }

C-/C++-Quelltext

#ifndef SELECTIONSCREEN_HPP
#define SELECTIONSCREEN_HPP

#include "Sprite.hpp"
#include <list>

class CSelectionScreen
{
    public:
        CSelectionScreen    ();
        ~CSelectionScreen    ();
        void Init            ();
        void Quit            ();
        void Render            ();

    private:
        CSprite *m_pSpriteSel;        // Selcection Screen
        CSprite *m_pSpriteBisasam;    // Bisasam
        list<CSprite> m_SpriteList; 
};

#endif

C-/C++-Quelltext

#include "SelectionScreen.hpp"

// Konstruktor
//
// Aufgabe: Allgemeine Initialisierungen
//
CSelectionScreen::CSelectionScreen()
{
    m_pSpriteSel = NULL;
    m_pSpriteBisasam = NULL;
} // Konstruktor

// Destruktor
CSelectionScreen::~CSelectionScreen    ()
{
    Quit();
} // Destruktor

// Init
//
// Aufgabe: Sprites erzeugen und laden
//
void CSelectionScreen::Init ()
{
    // SelectionScreen
    m_pSpriteSel = new CSprite;
    m_pSpriteSel->Load("Data/SelectionScreen.bmp");

    m_pSpriteBisasam = new CSprite;
    m_pSpriteBisasam->Load("Data/Karten/BisasamBig.bmp");
    m_pSpriteBisasam->SetColorKey (255, 0, 255);
    m_pSpriteBisasam->SetPos(220, 0);

    m_SpriteList.push_back (*m_pSpriteBisasam);

} // Init

// Quit
//
// Aufgabe: Sprites freigeben
//
void CSelectionScreen::Quit ()
{
    // Sel-Sprite freigeben
    if (m_pSpriteSel != NULL)
    {
        delete (m_pSpriteSel);
        m_pSpriteSel = NULL;
    }
    // Sel-Sprite freigeben
    if (m_pSpriteBisasam != NULL)
    {
        delete (m_pSpriteBisasam);
        m_pSpriteBisasam = NULL;
    }
} // Quit

// Rendern
void CSelectionScreen::Render ()
{
    m_pSpriteSel->Render ();

    list<CSprite>::iterator it = m_SpriteList.begin();

    while (it != m_SpriteList.end ())
    {
        // Einzelne Bilder Rendern
        it->Render();
        it++;
    }

} // Rendern

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;}
        int GetFrameWidth   () {return m_FrameWidth;}
        int GetFrameHeight  (){return m_FrameHeight;}

    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