spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

void CGegner::Update()
{

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

    // Gegner bewegen
    if(m_fRLBewegung == 1)
    {
        m_fXPos += 20.0f * g_pTimer->GetElapsed();
        if(m_fXPos > 730.0f)
        {
            m_fXPos = 730.0f;
            m_fRLBewegung = 0;
        }
    }

    if(m_fRLBewegung == 0)
    {
        m_fXPos -= 20.0f * g_pTimer->GetElapsed();
            if(m_fXPos < 0.0f)
            {
                m_fXPos = 0.0f;
                m_fRLBewegung = 1;
            }
    }
}// Update

C-/C++-Quelltext

// CheckCollisions
//
// Aufgabe: Kollisionen zwischen Asteroiden und Schüssen prüfen
//
void CGame::CheckCollisions ()
{
    // Schussliste des Spielers holen
    list<CShot> *ShotList = m_pPlayer->GetShotList ();

    // Schussliste des Gegners holen
    list<CShot> *ShotListOpponent = m_pOpponent->GetShotList ();
    list<CShot>::iterator ItShotOpponent;

    // Iteratoren für Asteroiden- und Schussliste sowie Explosionsliste
    list<CAsteroid>::iterator ItAsteroid = m_AsteroidList.begin ();
    list<CShot>::iterator ItShot;
    list<CExplosion>::iterator ItExplosion = m_ExplosionList.begin ();

    // Rects für Asteroiden und Schüsse sowie Spieler
    SDL_Rect RectAsteroid;
    SDL_Rect RectShot;
    SDL_Rect RectShotOpponent;
    SDL_Rect RectPlayer;
    SDL_Rect RectOpponent;
        
    // Alle Asteroiden durchlaufen
    while (ItAsteroid != m_AsteroidList.end () )
    {
        // Rect des Asteroiden holen
        RectAsteroid = ItAsteroid->GetRect ();

        // Rect des Spielers holen (Erweitert)
        RectPlayer = m_pPlayer->GetRect();

        // Alle Schüsse durchlaufen
        for (ItShot = ShotList->begin ();
            ItShot != ShotList->end ();
            ++ItShot)
        {
            // Rect des Schusses holen
            RectShot = ItShot->GetRect ();

            // Überschneiden sich die Rects?
            if (RectShot.y < RectAsteroid.y + RectAsteroid.h &&
                RectShot.y + RectShot.h > RectAsteroid.y &&
                RectShot.x < RectAsteroid.x + RectAsteroid.w &&
                RectShot.x + RectShot.w > RectAsteroid.x)
            {       
                // Ja, also gab es eine Kollision. Somit Schuss und
                // Asteroid deaktivieren
                ItAsteroid->SetAlive (false);
                ItShot->SetAlive (false);
                m_AsteroidDestroy++;            // Wieviele Asteroiden zerstört?
                m_pSoundAsteroid->PlaySound();  // Asteriod explodiert -> Soundeffekt   

                // Explosion erstellen
                SpawnExplosion ((RectAsteroid.x - RectAsteroid.w/2), (RectAsteroid.y - RectAsteroid.h/2));          
            }
        }
        // Kollision zwischen Asteroid und Spieler prüfen          
            if (RectPlayer.y < RectAsteroid.y + RectAsteroid.h &&
                RectPlayer.y + RectPlayer.h > RectAsteroid.y &&
                RectPlayer.x < RectAsteroid.x + RectAsteroid.w &&
                RectPlayer.x + RectPlayer.w > RectAsteroid.x)
            {
                // Ja, also gab es eine Kollision. Somit Spieler und
                // Asteroid deaktivieren
                ItAsteroid->SetAlive (false);
                m_pPlayer->SetHealth();
                m_pPlayer->Reset();
                // Asteriod explodiert -> Soundeffekt
                m_pSoundAsteroid->PlaySound();
            }

        // Asteroid löschen, falls deaktiviert
        if (ItAsteroid->IsAlive () )
            ItAsteroid++;
        else
            ItAsteroid = m_AsteroidList.erase (ItAsteroid);
    }
    
 
    for (ItShotOpponent = ShotListOpponent->begin();
        ItShotOpponent != ShotListOpponent->end(); ++ItShotOpponent)
    {
        // Rect des Gegner-Schusses holen
        RectShotOpponent = ItShotOpponent->GetRect ();
        // Rect des Gegners holen
        

        // Überschneiden sich die Rects?
            if (RectShotOpponent.y < RectPlayer.y + RectPlayer.h &&
                RectShotOpponent.y + RectShotOpponent.h > RectPlayer.y &&
                RectShotOpponent.x < RectPlayer.x + RectPlayer.w &&
                RectShotOpponent.x + RectShotOpponent.w > RectPlayer.x)
            {       
                // Ja, also gab es eine Kollision. Somit Schuss und
                // Asteroid deaktivieren
                ItShotOpponent ->SetAlive (false);
                m_pPlayer->Reset();
                m_pSoundAsteroid->PlaySound();  // Asteriod explodiert -> Soundeffekt       
            }
    }

} // CheckCollision