Hallo,
ich würde gerne eine Explosion bei einer Kollision zwischen Schuss und Asteroid oder Asteroid und Spieler haben, jedoch fühle ich mich damit grade etwas überfordert...
Muss ich eine eigene Explosionsklasse schreiben oder geht es auch anders?
Das Sprite habe ich schon, aber wie mache ich es, dass an der Position, wo davor der Asteroid bzw. der Spieler war, die Explosion stattfindet?
Ich dachte dass ich es mal so probiere:
Explosion.hpp
|
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
|
#ifndef EXPLOSION_HPP
#define EXPLOSION_HPP
#include "Sprite.hpp"
class CExplosion
{
public:
void Init (CSprite *pSpriteExplosion, float fXPos, float fYPos);
void Update ();
void Render ();
bool IsAlive () {return m_bIsAlive;}
void SetAlive (bool bIsAlive) {m_bIsAlive = bIsAlive;}
SDL_Rect GetRect () {return m_Rect;}
private:
CSprite *m_pSpriteExplosion; // Zeiger auf Explosions-Sprite
float m_fXPos; // X-Position der Explosion
float m_fYPos; // Y-Position der Explosion
float m_fAnimPhase; // Akt. Animationsphase der Explosion
bool m_bIsAlive; // "Lebt" die Explosion noch?
SDL_Rect m_Rect; // Rect der Explosion
};
#endif
|
Explosion.cpp
|
|
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
|
#include "Explosion.hpp"
// Init
//
// Aufgabe: Explosion initialisieren
//
void CExplosion::Init (CSprite *pSpriteExplosion, float fXPos, float fYPos)
{
// Zeiger auf Sprite kopieren und Koordinaten setzen
m_pSpriteExplosion = pSpriteExplosion;
m_fXPos = fXPos;
m_fYPos = fYPos;
// Animation beginnt beim ersten Einzelbild
m_fAnimPhase = 0.0f;
// Rect initialisieren
m_Rect.x = static_cast<int>(fXPos);
m_Rect.y = static_cast<int>(fYPos);
m_Rect.w = pSpriteExplosion->GetRect().w;
m_Rect.h = pSpriteExplosion->GetRect().h;
// Asteroid aktivieren
m_bIsAlive = true;
} // Init
// Update
//
// Aufgabe: Animation der Explosion
//
void CExplosion::Update ()
{
// Animieren
m_fAnimPhase += 12.0f * g_pTimer->GetElapsed ();
// Prüfen, ob die Animation am Ende angelangt ist, wenn ja, dann deaktivieren
if (m_fAnimPhase >= 16.0f)
{
m_bIsAlive = false;
}
} //Update
// Render
//
// Aufgabe: Explosion rendern
//
void CExplosion::Render ()
{
m_pSpriteExplosion->SetPos (m_fXPos, m_fYPos);
m_pSpriteExplosion->Render (m_fAnimPhase);
} // Render
|
Game.hpp
|
|
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
|
#ifndef GAME_HPP
#define GAME_HPP
#include "Player.hpp"
#include "Asteroid.hpp"
class CGame
{
public:
CGame ();
void Init ();
void Run ();
void Quit ();
private:
void ProcessEvents ();
void SpawnAsteroids ();
void RenderAsteroids ();
void CheckCollisions ();
void CheckPlayerCollisions ();
CPlayer *m_pPlayer; // Spieler-Instanz
CSprite *m_pSpriteBackground; // Sprite für den Hintergrund
CSprite *m_pSpriteAsteroid; // Sprite für die Asteroiden
//CSprite *m_pSpriteExplosion; //Sprite für eine Explosion
float m_fAsteroidTimer; // Zeitgeber für nächsten Asteroiden
bool m_bGameRun; // Läuft das Spiel noch?
list<CAsteroid> m_AsteroidList; // Liste der Asteroiden
};
#endif
|
Game.cpp:
in CGame::Init()
|
|
C-/C++-Quelltext
|
1
2
3
|
m_pSpriteExplosion = new CSprite;
m_pSpriteExplosion->Load ("Data/Explosion.bmp", 16, 64, 64);
m_pSpriteExplosion->SetColorKey (255, 0, 255);
|
in CGame::CheckCollisions()
|
|
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
|
void CGame::CheckCollisions ()
{
// Schussliste des Spielers holen
list<CShot> *ShotList = m_pPlayer->GetShotList ();
// Iteratoren für Asteroiden- und Schussliste
list<CAsteroid>::iterator ItAsteroid = m_AsteroidList.begin ();
list<CShot>::iterator ItShot;
// Rects für Asteroiden und Schüsse
SDL_Rect RectAsteroid;
SDL_Rect RectShot;
// Alle Asteroiden durchlaufen
while (ItAsteroid != m_AsteroidList.end () )
{
// Rect des Asteroiden holen
RectAsteroid = ItAsteroid->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);
|
Und hier dachte ich schreibe ich dann :
|
|
C-/C++-Quelltext
|
1
2
|
m_pSpriteExplosion->SetPos( XPos, YPos);
m_pSpriteExplosion->Render();
|
oder etwas in der Art
}
}
|
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
|
// Asteroid löschen, falls deaktiviert
if (ItAsteroid->IsAlive () )
ItAsteroid++;
else
ItAsteroid = m_AsteroidList.erase (ItAsteroid);
}
} // CheckCollision
|
So aber was mache ich falsch, weil wenn ich das Spiel dann sraten möchte bleibt es schwarz und beendet sich dann.
Ohne diese ganzen Explosionsteile funktioniert alles bestens...
Und was soll ich bei m_pSpriteExplosion->Setpos (XPos, YPos) reinschreiben, damit die Explosion am früheren Standort des Asteroids stattfindet??
Sry ist jetzt bissi viel Quellcode, aba vll kann mir ja wer helfen...[/cpp]
spieleprogrammierer.de »
Bücher - Support-Foren »
Hilfe zum Buch "C++ für Spieleprogrammierer" von Heiko Kalista »
Zitat von »"JoNnY"«
Aber es wird ja eine Zufallszahl ermittelt, wie kann ich denn da die Position ermitteln von den Asteroiden?
256 Farben
25.04.2024, 04:25
Zum Seitenanfang
