spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// Game.hpp
//

#ifndef GAME_HPP
#define GAME_HPP

#include "Player.hpp"
#include "Banana.hpp"
#include "Text.hpp"
#include <list>


class CGame
{
     public:
         CGame ();         
         
         void Init ();    
         void Run  ();     
         void Quit ();    
         void Menu ();

     private:
         void ProcessEvents  (); 
         

         bool m_bGameRun;            // Läuft das Spiel noch?
         bool m_bMenu;               // Läuft das Hauptmenü noch?
         int      m_Score;           // Der Score für ein Spiel
         CText    m_tScore;          // Text - Score

};

#endif

C-/C++-Quelltext

// Run
//
// Aufgabe: Der eigentliche "Herzschlag" des Spiels
//
void CGame::Run()
{
    
    char TextBuffer_Score[15];

    // Die "Herzschlag"-Schleife
    while (m_bGameRun == true)
    {

        // Hauptmenü aufrufen, falls noch aktiv
        if (m_bMenu == true)
        {
            Menu ();
        } // Menu

        
        // Framework updaten und Buffer löschen
        g_pFramework->Update ();
        g_pFramework->Clear  ();

        // Events überprüfen
        ProcessEvents ();

        // Hintergrundbild rendern
        m_pSpriteGame->Render ();

        // Spieler updaten und rendern
        m_pPlayer->Update ();
        m_pPlayer->Render ();

        // Neue Bananas hinzufügen
        SpawnBananas ();

        // Kollisionen überprüfen
        CheckCollisions ();

        // Bananas rendern
        RenderBananas ();

        sprintf_s(TextBuffer_Score, "Score: %i", m_Score);
        m_tScore.Draw (g_pFramework->GetRenderer(), "Schriftarten/comic.ttf", 50, TextBuffer_Score, { 0, 0, 0, 0 });
        // Gesammelte Bananas anzeigen
        

        // Erreichten Score anzeigen
        m_tScore.display (1320, 15, g_pFramework->GetRenderer());
        m_tScore.~CText();

        // Falls 'H' gedrückt wird, zum Hauptmenü
        // zurückkehren und Spielerstand zurücksetzen
        if (g_pFramework->KeyDown(SDL_SCANCODE_H))
            m_bMenu = true;


        // Spiel darstellen
        g_pFramework->Render ();

    }

} // Run

C-/C++-Quelltext

// Text.cpp
//

#include "Text.hpp"

// Konstruktor
//
CText::CText ()
{
}

void CText::Draw(SDL_Renderer *renderer,
            const string &font_path,
            int font_size,
            const string &message_text,
            const SDL_Color &color)
{
    m_text_texture = loadFont(renderer, font_path, font_size, message_text, color);
    SDL_QueryTexture(m_text_texture, nullptr, nullptr, &m_text_rect.w, &m_text_rect.h);
}


// Destruktor
//
CText::~CText ()
{
    TTF_CloseFont (m_pFont);
    SDL_DestroyTexture(m_text_texture);
    m_pFont = NULL;
}


void CText::display(int x, int y, SDL_Renderer *renderer)
{
    m_text_rect.x = x;
    m_text_rect.y = y;
    SDL_RenderCopy(renderer, m_text_texture, nullptr, &m_text_rect);
}


SDL_Texture *CText::loadFont(SDL_Renderer *renderer,
                             const string &font_path,
                             int font_size,
                             const string &message_text,
                             const SDL_Color &color)
{
    TTF_Font *m_pFont = TTF_OpenFont(font_path.c_str(), font_size);

    if (!m_pFont)
    {
        cout << "failed to load font!" << endl;
    }
    auto m_text_surface = TTF_RenderText_Solid (m_pFont, message_text.c_str(), color);
    if (!m_text_surface)
    {
        cout << "failed to load surface!" << endl;
    }
    if (!message_text.c_str())
    {
        cout << "failed to load message!" << endl;
    }
    auto text_texture = SDL_CreateTextureFromSurface(renderer, m_text_surface);
    if (!text_texture)
    {
        cout << "failed to load texture!" << endl;
    }
    SDL_FreeSurface (m_text_surface);
    return text_texture;
    SDL_DestroyTexture(text_texture);
}