Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!
Werbeanzeige
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
#ifndef GEGNER_HPP #define GEGNER_HPP #include <list> #include "Sprite.hpp" #include "Shot.hpp" class CGegner { public: CGegner (); ~CGegner (); void Render (); void Update (); float LebenAbfragen (); void LebenRedu (); list<CShot> *GetShotGegnerList () {return &m_ShotGegnerList;} SDL_Rect GetRect () {return m_Rect;} private: void ProcessShooting (); CSprite *m_pSpriteGegner; // Sprite für den Gegner CSprite *m_pSpriteGegnerShot; // Sprite für Laserschüsse float m_fXPos; // X-Position des Gegners float m_fYPos; // Y-Position des Gegners float m_fAnimPhase; // Aktuelle Animationsphase float m_fLeben; // Leben des Gegners float m_fRLBewegung; // Gegner nach Rechts oder Links bewegen bool m_bShotLock; // Darf der nächste Schuss raus? list<CShot> m_ShotGegnerList; // Liste der Schüsse SDL_Rect m_Rect; // Rect des Gegners }; #endif |
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 |
#include "Gegner.hpp" // Konstruktor // // Aufgabe:Sprites erzeugen und laden, Leben festlegen // CGegner::CGegner() { // Gegnersprite erstellen m_pSpriteGegner = new CSprite; m_pSpriteGegner->Load ("Data/Gegnerschiff.bmp", 20, 70, 70); m_pSpriteGegner->SetColorKey (0, 0, 0); // Schuss-Sprite erstellen m_pSpriteGegnerShot = new CSprite; m_pSpriteGegnerShot->Load ("Data/Gegnerschuss.bmp", 0, 32, 41); m_pSpriteGegnerShot->SetColorKey (0, 0, 0); // Rect initialisieren m_Rect.y = static_cast<int>(100.0f); m_Rect.x = static_cast<int>(520.0f); m_Rect.w = m_pSpriteGegner->GetRect().w; m_Rect.h = m_pSpriteGegner->GetRect().h; //Leben festlegen m_fLeben = 6.0f; //Position m_fXPos = 520.0f; m_fYPos = 100.0f; //Animationsphase m_fAnimPhase = 0.0f; //Start bewegung m_fRLBewegung = 1; //Schuss freigeben m_bShotLock = false; } // Destruktor // // Aufgabe:Sprites wieder freigeben // CGegner::~CGegner() { // Gegner-Sprite freigeben if (m_pSpriteGegner != NULL) { delete (m_pSpriteGegner); m_pSpriteGegner = NULL; } // Schuss-Sprite freigeben if (m_pSpriteGegnerShot != NULL) { delete (m_pSpriteGegnerShot); m_pSpriteGegnerShot = NULL; } } // Render // // Aufgabe: Sprite auf den Bildschirm bringen // void CGegner::Render() { m_pSpriteGegner->SetPos(m_fXPos, m_fYPos); m_pSpriteGegner->Render(m_fAnimPhase); // Iterator für Schussliste list<CShot>::iterator it = m_ShotGegnerList.begin (); // Schussliste durchlaufen while (it != m_ShotGegnerList.end ()) { // Schuss updaten it->GUpdate (); // Ist der Schuss noch aktiv? if (it->IsAlive ()) { // Ja, dann rendern it->Render (23.0f, 45.0f); it++; } else { // Nein, dann aus der Liste entfernen it = m_ShotGegnerList.erase (it); m_bShotLock = false; } } }// Render // Update // // Aufgabe: Gegner Schiff updaten // 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 // Leben reduzieren // // Aufgabe: Leben um 1 reduzieren // void CGegner::LebenRedu() { m_fLeben--; if(m_fLeben < 0) m_fLeben = 0.0f; } // Leben abfragen // // Aufgabe: Leben zurück geben // float CGegner::LebenAbfragen() { return(m_fLeben); } // Processshooting // // Aufgabe: Schüsse abgeben // void CGegner::ProcessShooting() { // Wurde Space gedrückt und darf geschossen werden? if (m_bShotLock == false) { // Neuen Schuss erzeugen und initialisieren CShot Shot; Shot.Init (m_pSpriteGegnerShot, m_fXPos, m_fYPos); // Schuss in Liste einfügen m_ShotGegnerList.push_back (Shot); // Schießen erst wieder erlaubt, wenn Space losgelassen m_bShotLock = true; } } |
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
#ifndef GAME_HPP #define GAME_HPP #include "Player.hpp" #include "Asteroid.hpp" #include "Lebensanzeige.hpp" #include "Gegner.hpp" class CGame { public: CGame (); void Init (); void Run (); void Quit (); private: void ProcessEvents (); void SpawnAsteroids (); void RenderAsteroids (); void CheckCollisions (); CLebensanzeige *m_pLebensanzeige; // Lebensanzeige-Instanz CPlayer *m_pPlayer; // Spieler-Instanz CSprite *m_pSpriteBackground; // Sprite für den Hintergrund CSprite *m_pSpriteAsteroid; // Sprite für die Asteroiden CGegner *m_pGegner; // Gegner-Instanz float m_fAsteroidTimer; // Zeitgeber für nächsten Asteroiden bool m_bGameRun; // Läuft das Spiel noch? float m_Leben; // Leben des Spielers list<CAsteroid> m_AsteroidList; // Liste der Asteroiden }; #endif |
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 |
// CheckCollisions // // Aufgabe: Kollisionen zwischen Asteroiden und Schüssen prüfen // void CGame::CheckCollisions () { // Schussliste des Spielers holen list<CShot> *ShotList = m_pPlayer->GetShotList (); list<CShot>::iterator ItShot; // Schussliste des Gegners holen list<CShot> *ShotGegnerList = m_pGegner->GetShotGegnerList (); list<CShot>::iterator ItShotGegner; // Iteratoren für Asteroiden list<CAsteroid>::iterator ItAsteroid = m_AsteroidList.begin (); // Rects für Asteroiden und Schüsse SDL_Rect RectAsteroid; SDL_Rect RectShot; SDL_Rect RectPlayer; SDL_Rect RectShotGegner; // Alle Asteroiden durchlaufen while (ItAsteroid != m_AsteroidList.end () ) { // Rect des Asteroiden RectAsteroid = ItAsteroid->GetRect (); //Korrektur für das Rect des Asteroiden RectAsteroid.w = 64; RectAsteroid.h = 64; // Rect des Spielers holen RectPlayer = m_pPlayer->GetRect(); // Kollision zwischen Spieler und Asteroid if (RectPlayer.y < RectAsteroid.y + RectAsteroid.h && RectPlayer.y + RectPlayer.h > RectAsteroid.y && RectPlayer.x < RectAsteroid.x + RectAsteroid.w && RectPlayer.x + RectPlayer.h > RectAsteroid.x) { // Ja, also gab es eine Kollision. //Asteroid löschen, Spieler Leben abziehen m_pPlayer->LebenRedu(); m_Leben = m_pPlayer->LebenAbfragen(); ItAsteroid->SetAlive (false); } // 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); } } // Asteroid löschen, falls deaktiviert if (ItAsteroid->IsAlive () ) ItAsteroid++; else ItAsteroid = m_AsteroidList.erase (ItAsteroid); } // Alle Schüsse des Gegners durchlaufen for(ItShotGegner = ShotGegnerList->begin(); ItShotGegner != ShotGegnerList->end(); ItShotGegner++) { // Rect des Spielers holen RectPlayer = m_pPlayer->GetRect(); // Rect des Schusses holen RectShotGegner = ItShotGegner->GetRect (); // Kollision zwischen Spieler und Gegnerschuss if (RectPlayer.y < RectShotGegner.y + RectShotGegner.h && RectPlayer.y + RectPlayer.h > RectShotGegner.y && RectPlayer.x < RectShotGegner.x + RectShotGegner.w && RectPlayer.x + RectPlayer.h > RectShotGegner.x) { // Leben reduzieren wenn getroffen und Schuss löschen ItShotGegner->SetAlive (false); m_pPlayer->LebenRedu(); m_Leben = m_pPlayer->LebenAbfragen(); } } } // CheckCollision |
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
// Render(Mitteln) // // Aufgabe: Schuss rendern // void CShot::Render (float m_fMitteln, float m_fUnten) { if (m_bIsAlive == true) { // Koordinaten setzen und rendern m_pSpriteShot->SetPos (m_fXPos + m_fMitteln, m_fYPos + m_fUnten); m_pSpriteShot->Render (); } } // Render // Update // // Aufgabe: Schuss bewegen und Position prüfen // void CShot::GUpdate () { // Schuss bewegen m_fYPos += 100.0f * g_pTimer->GetElapsed (); m_Rect.y = static_cast<int>(m_fYPos); // Deaktivieren, falls außerhalb des Bildschirms if (m_fYPos > 580.0f) m_bIsAlive = false; } // Update |
Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »Chris13« (18.03.2011, 15:41)
Also soweit ich das sehe müsste es eigentlich funktionieren und ich vermute, der Fehler liegt woanders. Ich denke mal, die Schüsse des Gegnerschiffs werden mit einem Timer ausgelöst und das funktioniert auch. Vielleicht stimmt was mit der Game.cpp nicht.
Und noch ein paar Verbesserungsvorschläge:
1. Ich finde so ein Deutsch - Englisch - Gemisch wie SpriteGegnerShot äußerst unhübsch. Vielleicht solltest du versuchen entweder deutsche oder englische Bezeichner zu nehmen, nur so als Tipp.
2. Für die Leben in der Gegnerklasse bietet sich doch ein int an, denn die Leben scheinen immer nur ganze Zahlen zu sein. Float macht da eigentlich keinen Sinn.
3. LebenAbfragen() ist kurz also könntest du wie bei GetRect() die Definition in Gegner.hpp vornehmen.
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
#ifndef SHOT_HPP #define SHOT_HPP #include "Sprite.hpp" class CShot { public: void Init (CSprite *pSpriteShot, float fXPos, float fYPos); void Update (); void GUpdate (); void Render (); void Render (float m_fMitteln, float m_fUnten); bool IsAlive () {return m_bIsAlive;} void SetAlive (bool bIsAlive) {m_bIsAlive = bIsAlive;} SDL_Rect GetRect () {return m_Rect;} float GetMitt () {return m_fTempMit;} float GetUnt () {return m_fTempUnt;} private: CSprite *m_pSpriteShot; // Zeiger auf Laser-Sprite float m_fXPos; // X-Position des Schusses float m_fYPos; // Y-Position des Schusses bool m_bIsAlive; // "Lebt" der Schuss noch? float m_fTempMit; // Temp Mitteln float m_fTempUnt; // Temp Unten SDL_Rect m_Rect; // Rect des Schusses }; #endif |
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
// Render(Mitteln) // // Aufgabe: Schuss rendern // void CShot::Render (float m_fMitteln, float m_fUnten) { if (m_bIsAlive == true) { m_fTempMit = m_fMitteln; m_fTempUnt = m_fUnten; m_pSpriteShot->SetPos (m_fXPos + m_fMitteln, m_fYPos + m_fUnten); m_pSpriteShot->Render (); } } // Render(Mitteln) |
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
// Alle Schüsse des Gegners durchlaufen for(ItShotGegner = ShotGegnerList->begin(); ItShotGegner != ShotGegnerList->end(); ItShotGegner++) { // Rect des Spielers holen RectPlayer = m_pPlayer->GetRect(); // Rect des Schusses holen RectShotGegner = ItShotGegner->GetRect (); // Kollision zwischen Spieler und Gegnerschuss if (RectPlayer.y < RectShotGegner.y + ItShotGegner->GetUnt () + RectShotGegner.h && RectPlayer.y + RectPlayer.h > RectShotGegner.y + ItShotGegner->GetUnt () && RectPlayer.x < RectShotGegner.x + ItShotGegner->GetMitt () + RectShotGegner.w && RectPlayer.x + RectPlayer.h > RectShotGegner.x + ItShotGegner->GetMitt ()) { // Leben reduzieren wenn getroffen und Schuss löschen ItShotGegner->SetAlive (false); m_pPlayer->LebenRedu(); m_Leben = m_pPlayer->LebenAbfragen(); } } |
Dieser Beitrag wurde bereits 8 mal editiert, zuletzt von »Chris13« (18.03.2011, 20:46)
Zitat
void CShot::Render (float m_fMitteln, float m_fUnten)
Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »Phalax« (18.03.2011, 21:15)
Zitat
void CShot::Render (float m_fMitteln, float m_fUnten)
m_ sollte eigentlich zur Kenntnismachung von Klassenmembern genutzt werden.
Ich hoffe das klingt jetzt nicht zu pingelig, aber ich denke es ist besser sich gleich die geläufige Variante anzugewöhnen.
TigerClaw25
unregistriert
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// Rect des Gegner-Schusses holen RectShotOpponent = ItShotOpponent->GetRect (); // Rect des Gegners holen RectOpponent = m_pOpponent->GetRect(); // Rect des Spielers holen RectPlayer = m_pPlayer->GetRect(); if (RectOpponent.x = RectPlayer.x) ItShotOpponent->SetAlive (true); else ItShotOpponent->SetAlive (false); / } |
Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »TigerClaw25« (17.04.2013, 11:45)
Ich suche bereits nach mehreren Möglichkeiten, um das gegnerische Raumschiff schießen zu lassen.
Habe mich also als erstes darum gekümmert, dass dieses in Richtung x-Achse hin und her fliegt. Bevor ich dieses in einem bestimmten Muster fliegen lassen möchte, muss ich natürlich noch festlegen, wann geschossen werden darf. Das dies über die Funktion ProcessShooting von COpponent geschieht, habe ich in der Kollisionsabfrage in der CGame folgendes eingefügt:
C-/C++-Quelltext
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 // Rect des Gegner-Schusses holen RectShotOpponent = ItShotOpponent->GetRect (); // Rect des Gegners holen RectOpponent = m_pOpponent->GetRect(); // Rect des Spielers holen RectPlayer = m_pPlayer->GetRect(); if (RectOpponent.x = RectPlayer.x) ItShotOpponent->SetAlive (true); else ItShotOpponent->SetAlive (false); / }
Sobald mein Raumschiff getroffen wird, wird es an die Startposition gesetzt- Leider funktioniert meine if Abfrage nicht, in der ich prüfen möchte, ob beide die selben Koordinatejn besitzen. Dann nämlich soll ein Schuss abgefeuert werden. Es passiert aber nichts.
Community-Fossil
Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer
Werbeanzeige