spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

Funktionsaufruf:

    CSprite *pSpriteIntro_Text = NULL; 
    pSpriteIntro_Text = LoadStory(ID_Story); //Storry Datei laden
    //pSpriteIntro_Text -> Load("Data/Emphasis/Storry/Storry_2.Emphasis");
    pSpriteIntro_Text -> SetColourKey(205,179,139);
   //dann rendern
   //und nach dem rendern per delete freigeben

Funktion:

CSprite* CGame::LoadStory(const int ID_Story)
{
    CSprite *Sprite = new CSprite; //CSprite für den Text
    if(ID_Story == 1)
        Sprite.Load("Data/Emphasis/Storry/Storry_1.Emphasis");
    else if(ID_Story == 2)
        Sprite.Load("Data/Emphasis/Storry/Storry_2.Emphasis");
    
    return Sprite;
}

C-/C++-Quelltext

Sprite.hpp:

private:
    string sPath; //Der Pfad, wo die Bilddatei liegt

C-/C++-Quelltext

Sprite.cpp:

CSprite& CSprite::operator =(CSprite& rhs)
{
    cout << rhs.sPath.c_str();
    Load(rhs.sPath);

    return *this;
}

C-/C++-Quelltext

Funktionsaufruf (unverändert):

        SpriteIntro_Text = LoadStory(ID_Story); //Storry Datei laden
    //pSpriteIntro_Text -> Load("Data/Emphasis/Storry/Storry_2.Emphasis");
    SpriteIntro_Text.SetColourKey(205,179,139);

C-/C++-Quelltext

Ladefunktion (unverändert):

CSprite CGame::LoadStory(const int ID_Storry)
{
    CSprite TempSprite; //Temporäres CSprite für den Text
    if(ID_Storry == 1)
        TempSprite.Load("Data/Emphasis/Story/Story_1.Emphasis");
    else if(ID_Storry == 2)
        TempSprite.Load("Data/Emphasis/Story/Story_2.Emphasis");
    
    return TempSprite;
}

C-/C++-Quelltext

Sprite.hpp:

public:
    CSprite();
    SDL_Surface *GetSurface() { return(m_pImage); }
    CSprite &operator = (CSprite& rhs); //Überladen des = Operators

private:
    SDL_Surface *m_pScreen; //Das Surface für den Screen, in den Gerendert wird
    SDL_Surface *m_pImage; // Das Surface für das Bild, in dem sich das zu rendernde Bild befindet

C-/C++-Quelltext

Sprite.cpp:

//Standard - Konstruktor des Sprites
//Holt den Screen für das Ziel - Surface vom Framework
CSprite::CSprite()
{
    m_pImage = NULL;
    m_pScreen = g_pFramework -> GetSurface();
}

CSprite& CSprite::operator =(CSprite& rhs)
{
    m_pImage = new SDL_Surface(*rhs.GetSurface());
    return *this;
}

C-/C++-Quelltext

Funktionsaufruf:

        CSprite *SpriteIntroText = NULL;
        SpriteIntro_Text = LoadStory(ID_Story); //Storry Datei laden
    //pSpriteIntro_Text -> Load("Data/Emphasis/Storry/Storry_2.Emphasis");
    SpriteIntro_Text -> SetColourKey(205,179,139); 
        //Hier noch rendern
        delete (SpriteIntro_Text);

Ladefunktion:

CSprite *CGame::LoadStory(const int ID_Storry)
{
    CSprite *Sprite = new CSprite; //CSprite für den Text
    if(ID_Storry == 1)
        Sprite -> Load("Data/Emphasis/Story/Story_1.Emphasis");
    else if(ID_Storry == 2)
        Sprite -> Load("Data/Emphasis/Story/Story_2.Emphasis");
    
    return Sprite;
}

C-/C++-Quelltext

Game.cpp:

void CGame::RenderStory(const int &ID_Story)
{
    //Story rendern
    bool bIntro = true; //Abbruchbedningung für das Intro
    float fYPos = 600.0f;
    SDL_Event Event;

    //Sprites für den Text initialisieren
    CSprite* SpriteIntro_Text = NULL; 

    SpriteIntro_Text = LoadStory(ID_Story); //Storry Datei laden
    //pSpriteIntro_Text -> Load("Data/Emphasis/Storry/Storry_2.Emphasis");
    SpriteIntro_Text -> SetColourKey(205,179,139); 

    do
    {
        g_pFramework -> Update();
        g_pFramework -> Clear();

        //Text des Intros rendern
        //RenderText("Escape - Taste drücken",40,85,85,85,280,250);
        SpriteIntro_Text -> SetPos(0.0f,fYPos);
        SpriteIntro_Text -> Render();
        
        g_pFramework -> Flip();

        fYPos -= 25 * g_pTimer -> GetElapsed();

        //Abbruchbedingung
        if(SDL_PollEvent(&Event))
        {
            switch(Event.type)
            {
                //Wurde eine Taste gedrückt?
                case(SDL_KEYDOWN):
                    {
                        switch(Event.key.keysym.sym)
                        {
                            case (SDLK_ESCAPE):
                                {
                                    bIntro = false;
                                }
                        }
                    }break;
            }
        }
    }while(bIntro && fYPos > -1247.0f);
    delete (SpriteIntro_Text);
}

//Funktion zum Laden der Storry
CSprite* CGame::LoadStory(const int ID_Storry)
{
    CSprite* Sprite = new CSprite; //CSprite für den Text
    if(ID_Storry == 1)
        Sprite -> Load("Data/Emphasis/Story/Story_1.Emphasis");
    else if(ID_Storry == 2)
        Sprite -> Load("Data/Emphasis/Story/Story_2.Emphasis");
    
    return Sprite;
}

C-/C++-Quelltext

Sprite.hpp:

#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 Render();
    void Render(float fFrameNumber);
    void SetColourKey(int R, int G, int B);
    void SetAlphaKey(Uint8 AlphaValue);
    void SetPos(float fXPos, float fYPos);
    SDL_Rect GetRect() { return (m_Rect); };

private:
    SDL_Surface *m_pScreen; //Das Surface für den Screen, in den Gerendert wird
    SDL_Surface *m_pImage; // Das Surface für das Bild, in dem sich das zu rendernde Bild befindet
    SDL_Rect m_Rect; //Das Rect (Rechteck) für das Bild
    SDL_Rect m_FrameRect; //Das Rect für die Animationsphase
    int m_NumFrames; //Anzahl der Animationsphasen
    int m_FrameWidth; //Breite der Animationsphase 
    int m_FrameHeight; //Höhe der Animationsphase
    int m_NumFramesX; //Anzahl der Animationsphasen in X - Richtung
};


#endif

C-/C++-Quelltext

Site - Klasse:

#include "Sprite.hpp"

//Standard - Konstruktor des Sprites
//Holt den Screen für das Ziel - Surface vom Framework
CSprite::CSprite()
{
    m_pImage = NULL;
    m_pScreen = g_pFramework -> GetSurface();
}

//Destruktor
//Gibt das Surface vom Image frei
CSprite::~CSprite()
{
    if(m_pImage != NULL)
    {
        SDL_FreeSurface(m_pImage);
        m_pImage = NULL;
    }
}

//Load - Funktion.
//Ermöglicht das Laden eines nicht animierten Sprites
void CSprite::Load(const string sFilename)
{
    m_pImage = SDL_LoadBMP(sFilename.c_str()); //BMP laden

    //Fehlerabfrage
    if (m_pImage == NULL)
    {
        cout << "Fehler beim Laden von: " << sFilename.c_str() << endl;
        cout << "Fehlermeldung: " << SDL_GetError() << endl;

        //Framework herunterfahren
        g_pFramework -> Quit();
        //Gesammtes Programm herunterfahren
        exit(1);
    }

    //Rect initialisieren
    m_Rect.x = 0; //X - Pos für die linke obere Ecke im Rect
    m_Rect.y = 0; //Y - Pos für die linke obere Ecke im Rect
    m_Rect.w = m_pImage -> w; //Breite des Rect
    m_Rect.h = m_pImage -> h; //Höhe des Rect
}

//Load - Funktion
//Ermöglicht das laden von animierten Sprites
void CSprite::Load(const string sFilename, int NumFrames, int FrameWidth, int FrameHeight)
{
    //Laden der Bitemap
    Load(sFilename.c_str());

    //Rect für die Animationsphase initialisieren
    m_NumFrames = NumFrames;
    m_FrameWidth = FrameWidth;
    m_FrameHeight = FrameHeight;
    m_FrameRect.w = FrameWidth;
    m_FrameRect.h = FrameHeight;
    m_NumFramesX = (m_pImage -> w) / FrameWidth;
}

//Funktion zum Setzen der Poition des Sprites
void CSprite::SetPos(float fXPos, float fYPos)
{
    m_Rect.x = static_cast<int> (fXPos);
    m_Rect.y = static_cast<int> (fYPos);
}

//Funktion zum definieren des Colour - Keys
void CSprite::SetColourKey(int R, int G, int B)
{
    if(SDL_SetColorKey(m_pImage,SDL_SRCCOLORKEY,SDL_MapRGB(m_pImage->format,R,G,B)) < 0)
        cout << "Fehler beim setzten des Colour - Keys!\nFehler: " << SDL_GetError() << endl;
}

//Funktion zum definieren der Transparenz des Sprites
void CSprite::SetAlphaKey(Uint8 AlphaValue)
{
    SDL_SetAlpha(m_pImage,SDL_SRCALPHA, static_cast<Uint8> (AlphaValue));
}

//Funktion zum Rendern eines Nicht animierten Sprites
void CSprite::Render()
{
    SDL_BlitSurface(m_pImage,NULL,m_pScreen,&m_Rect);
}

//Funktion zum Rendern eines animierten Sprites
void CSprite::Render(float fFrameNumber)
{
    // 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;

    //Rendern
    SDL_BlitSurface(m_pImage,&m_FrameRect,m_pScreen,&m_Rect);
}