spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include "Opponent.h"

// Konstruktor
//
// Aufgabe: Allgemeine Initialisierungen
//
COpponent::COpponent ()
{
    m_pSpriteOpponent = NULL;
    m_pSpriteShot = NULL;

    m_Health = 10;

} // Konstruktor

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

    m_pSpriteOpponent->Load ("Data/Opponent.bmp", 11, 64,64);
    m_pSpriteOpponent->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);

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

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

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

} // Quit

// Reset
//
// Aufgabe: Spielerwerte auf Standard setzen
//
void COpponent::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_pSpriteOpponent->GetRect().w;
    m_Rect.h = m_pSpriteOpponent->GetRect().h;

} // Reset

// Render
//
// Aufgabe: Spieler und Schüsse rendern
//
void COpponent::Render ()
{
    // Position des Spielers setzen und Sprite rendern
    m_pSpriteOpponent->SetPos (m_fXPos, m_fYPos);
    m_pSpriteOpponent->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 COpponent::Update ()
{
    // Prüfen, ob geschossen wurde
    ProcessShooting ();

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

} // Update


// ProcessShooting
//
// Aufgabe: Waffe abfeuern
//
void COpponent::ProcessShooting ()
{
    // Wurde Space gedrückt und 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

C-/C++-Quelltext

bool ShotLock(bool x) {m_bShotLock = x; return m_bShotLock;}

C-/C++-Quelltext

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

        if (X == m_Rect.x)      
            m_bShotLock = false;
                
        else 
            m_bShotLock = true;
        

} // EnemyShot

C-/C++-Quelltext

    // Gegner updaten und rendern
        m_pEnemy->Update ();
        m_pEnemy->Render ();

        SDL_Rect RectPlayer;
        RectPlayer = m_pPlayer->GetRect();
        m_pEnemy->EnemyShot (static_cast<int>(RectPlayer.x));