spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include "Enemy.h"

// Konstruktor
//
// Aufgabe: Allgemeine Initialisierungen
//
CEnemy::CEnemy ()
{
    m_pSpriteEnemy = NULL;
    m_pSpriteShot = NULL;
    m_pPlayer = NULL;

    m_Health = 10;

} // Konstruktor

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

    m_pSpriteEnemy->Load ("Data/Opponent.bmp", 11, 64,64);
    m_pSpriteEnemy->SetColorKey (255, 0, 255);

    // Schuss-Sprite erstellen
    m_pSpriteShot = new CSprite;

    m_pSpriteShot->Load ("Data/Laser.bmp", 0, 64, 64);
    m_pSpriteShot->SetColorKey (255, 0, 255);

    // Neuen Spieler initialisieren
    m_pPlayer = new CPlayer;
    m_pPlayer->Init ();
    m_pPlayer->Reset ();

    // Bewegung initialisieren
    m_moving = true;
    
} // Init

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

    // Schuss-Sprite freigeben
    if (m_pSpriteShot != NULL)
    {
        delete (m_pSpriteShot);
        m_pSpriteShot = NULL;
    }

} // Quit

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

    // Animationsphase
    m_fAnimPhase = 5.0f;

    // Es darf geschossen werden
    m_bShotLock = false;

    // Rect initialisieren (Erweiterung für Kollision zwischen Asteroid und Spieler)
    m_Rect.x = static_cast<int>(m_fXPos);
    m_Rect.y = static_cast<int>(m_fYPos);
    m_Rect.w = m_pSpriteEnemy->GetRect().w;
    m_Rect.h = m_pSpriteEnemy->GetRect().h;

} // Reset

// EnemyShot
//
// Aufgabe: Schuss des Gegners abfeuern, wenn Spieler in Reichweite
//
void CEnemy::EnemyShot()
{

    // Schuss des Gegners steuern:
    SDL_Rect RectPlayer;
    
    
        RectPlayer = m_pPlayer->GetRect();

        if (static_cast<int>(RectPlayer.x) == m_Rect.x)     
            m_bShotLock = false;
                
        else 
            m_bShotLock = true;
        

} // EnemyShot

// Render
//
// Aufgabe: Spieler und Schüsse rendern
//
void CEnemy::Render ()
{
    // Position des Spielers setzen und Sprite rendern
    m_pSpriteEnemy->SetPos (m_fXPos, m_fYPos);
    m_pSpriteEnemy->Render (m_fAnimPhase);

    // Iterator für Schussliste
    list<CShot>::iterator it = m_ShotList.begin ();

    // Schussliste durchlaufen
    while (it != m_ShotList.end ())
    {
        // Schuss updaten
        it->Update2 ();

        // Ist der Schuss noch aktiv?
        if (it->IsAlive ())
        {
            // Ja, dann rendern
            it->Render ();
            it++;
        }
        else
        {
            // Nein, dann aus der Liste entfernen
            it = m_ShotList.erase (it);
        }

    }

} // Render

// Update
//
// Aufgabe: Spieler updaten
//
void CEnemy::Update ()
{
// Nach links?
    if (m_moving == true)
    {
        m_fXPos += 200.0f * g_pTimer->GetElapsed ();
        m_fAnimPhase += 20.0f * g_pTimer->GetElapsed ();
        
        if (m_fXPos > 730.0f)
        {
            m_fXPos = 730.0f;
            m_moving = false;
        }

    }
    // Nach rechts?
    if (m_moving == false)
    {   
        m_fXPos -= 200.0f * g_pTimer->GetElapsed ();
        m_fAnimPhase -= 20.0f * g_pTimer->GetElapsed ();
        if (m_fXPos < 0.0f)
        {
            m_fXPos = 0.0f;
            m_moving = true;
        }

    }

    // Animationsphase prüfen
        if (m_fAnimPhase < 0.0f)
            m_fAnimPhase = 0.0f;
        else if (m_fAnimPhase > 10.0f)
            m_fAnimPhase = 10.0f;

    // Prüfen, ob geschossen wurde
    ProcessShooting ();

    m_Rect.x = static_cast<int>(m_fXPos);

    // Gegnerschuss
    EnemyShot();

} // Update

// ProcessShooting
//
// Aufgabe: Waffe abfeuern
//
void CEnemy::ProcessShooting ()
{
    // Darf geschossen werden?
    if (m_bShotLock == false)
    {
        // Neuen Schuss erzeugen und initialisieren
        CShot Shot;

        Shot.Init (m_pSpriteShot, m_fXPos, m_fYPos);

        // Schuss in Liste einfügen
        m_ShotList.push_back (Shot);

        // Schießen erst wieder erlaubt, wenn Space losgelassen
        m_bShotLock = true;

    }


} // ProcessShooting