spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include "Player.hpp"
#include <Windows.h>

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

} // Konstruktor



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


    m_pSpritePlayer->Load("Laser.bmp", 0, 64, 64);
    m_pSpritePlayer->SetColorKey(255, 0, 255);

} // Init



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

} // Quit



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

} // 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();

} // Render



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

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

} // Update



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

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

    }
    // Spieler wurde nicht bewegt
    else
    {
    }

} // ProcessMoving



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

} // CheckPosition

C-/C++-Quelltext

#ifndef PLAYER_HPP
#define PLAYER_HPP

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

class CPlayer
{
public:
    CPlayer();
    void Init();
    void Quit();
    void Render();
    void Update();
    void Reset();

private:
    void ProcessMoving();
    void CheckPosition();

    CSprite *m_pSpritePlayer; // Sprite für Spieler
    float m_fXPos;            // X-Position des Spielers
    float m_fYPos;            // Y-Position des Spielers


};

#endif

C-/C++-Quelltext

#include "Sprite.hpp"
#include <Windows.h>

// 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;

        //zum testen ob immer noch ein Fehler beim Laden des Bildes kommt
        Sleep(100000);

        // 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

#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 der Animationsphase
    int m_FrameHeight;      //Höhe einer Animationsphase
    int m_NumFramesX;       //Wie viele Anim-Phasen in X-Richtung?
};

#endif