spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#pragma once
#include "SDL.h"
#include "Sprite.hpp"

class CSprite;

class CCandy
{
public:
    void Init (CSprite *pSpriteCandy, float fXPos, float fYPos);
    void Render ();
    bool IsAlive () {return m_bIsAlive;}
    void SetAlive (bool bIsAlive) {m_bIsAlive = bIsAlive;}
    SDL_Rect GetRect () {return m_Rect;}

private:
    CSprite *m_pSpriteCandy;
    float m_fXPos;
    float m_fYPos;
    int FrameRect;
    bool m_bIsAlive;
    SDL_Rect m_Rect;
};


#include "Candy.hpp"


void CCandy::Init (CSprite *pSpriteCandy, float fXPos, float fYPos)
{
    m_pSpriteCandy = pSpriteCandy;
    m_fXPos = fXPos;
    m_fYPos = fYPos;

    FrameRect = rand()%3;

    m_Rect.x = static_cast<int>(fXPos);
    m_Rect.y = static_cast<int>(fYPos);
    m_Rect.w = 32;
    m_Rect.h = 32;

    m_bIsAlive = true;
}

void CCandy::Render ()
{
    m_pSpriteCandy->SetPos (m_fXPos, m_fYPos);
    m_pSpriteCandy->Render (static_cast<float>(FrameRect));
}

C-/C++-Quelltext

#pragma once
#include "SDL.h"
#include "Player.hpp"
#include "Sprite.hpp"
#include "Candy.hpp"
#include <list>

class CCandy;
class CSprite;
class CPlayer;

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

private:
    void ProcessEvents ();
    void SpawnCandy ();
    void RenderCandy ();
    void CheckCollision ();

    CPlayer *m_pPlayer;
    CSprite *m_pSpriteBackground;
    CSprite *m_pSpriteCandy;
    float m_fCandyTimer;
    bool m_bGameRun;
    list<CCandy> m_CandyList;
};


#include "game.hpp"
#include <time.h>

CGame::CGame ()
{
    m_pPlayer = NULL;
    m_pSpriteBackground = NULL;
    m_pSpriteCandy = NULL;

    srand((unsigned)time(NULL));
}

void CGame::Init ()
{
    m_pPlayer = new CPlayer;
    m_pPlayer->Init ();
    m_pPlayer->Reset ();

    m_pSpriteBackground = new CSprite ();
    m_pSpriteBackground->Load ("Background.bmp");

    m_pSpriteCandy = new CSprite ();
    m_pSpriteCandy->Load ("Candy.bmp", 2, 32, 32);
    m_pSpriteCandy->SetColorKey (255, 255, 255);

    m_fCandyTimer = 4.0f;

    m_bGameRun = true;
}

void CGame::Quit ()
{
    if (m_pPlayer != NULL)
    {
        delete (m_pPlayer);
        m_pPlayer = NULL;
    }

    if (m_pSpriteBackground != NULL)
    {
        delete (m_pSpriteBackground);
        m_pSpriteBackground = NULL;
    }

    if (m_pSpriteCandy != NULL)
    {
        delete (m_pSpriteCandy);
        m_pSpriteCandy = NULL;
    }
}

void CGame::Run ()
{
    while (m_bGameRun == true)
    {
        ProcessEvents ();

        g_pFramework->Update ();

        m_pSpriteBackground->Render ();

        m_pPlayer->Update ();

        CheckCollision ();

        SpawnCandy ();

        RenderCandy ();

        m_pPlayer->Render ();

        g_pFramework->Flip ();
    }
}

void CGame::ProcessEvents ()
{
    SDL_Event Event;

    if (SDL_PollEvent (&Event))
    {
        switch (Event.type)
        {
        case (SDL_QUIT):
            {
                m_bGameRun = false;
            } break;


        case(SDL_KEYDOWN):
            {
                switch (Event.key.keysym.sym)
                {
                case (SDLK_ESCAPE):
                    {
                        m_bGameRun = false;
                    } break;
                }
            } break;
        }
    }
}

void CGame::SpawnCandy ()
{
    m_fCandyTimer += g_pTimer->GetElapsed ();

    if (m_fCandyTimer >= 4.0f)
    {
        CCandy Candy;

        int XPos = rand()%610;
        int YPos = rand()%448;

        Candy.Init (m_pSpriteCandy, static_cast<float>(XPos), static_cast<float>(YPos));

        m_CandyList.push_back (Candy);

        m_fCandyTimer = 0.0f;
    }
}


void CGame::CheckCollision ()
{
    list<CCandy>::iterator ItCandy = m_CandyList.begin ();

    SDL_Rect RectCandy;
    SDL_Rect RectPlayer;

    while (ItCandy != m_CandyList.end () )
    {
        RectCandy = ItCandy->GetRect ();

        RectPlayer = m_pPlayer->GetRect ();

        if (RectPlayer.y < RectCandy.y + RectCandy.h &&
            RectPlayer.y + RectPlayer.h > RectCandy.y &&
            RectPlayer.x < RectCandy.x + RectCandy.w &&
            RectPlayer.x + RectPlayer.w > RectCandy.x)
        {
            ItCandy->SetAlive (false);
        }
    }
    if (ItCandy->IsAlive () )
        ItCandy++;
    else
        ItCandy = m_CandyList.erase (ItCandy);

}


void CGame::RenderCandy ()
{
    list<CCandy>::iterator It;

    for (It = m_CandyList.begin (); It != m_CandyList.end (); It++)
    {
        It->Render ();
    }
}

C-/C++-Quelltext

SDL_Rect CPlayer::GetRect ()
{
    SDL_Rect temprect;

    temprect.x = m_fXPos;
    temprect.y = m_fYPos;
    temprect.w = 50;
    temprect.h = 60;
    
    return temprect;
}