Du bist nicht angemeldet.

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!

SDL Gegnerraumschiff Schüsse

Werbeanzeige

Chris13

Frischling

  • »Chris13« ist der Autor dieses Themas

Beiträge: 73

  • Private Nachricht senden

1

18.03.2011, 14:36

SDL Gegnerraumschiff Schüsse

Hallo,

Danke schonmal das ihr euch bemüht mir zu zu Helfen :). Ich habe dem SDL_Game ein Gegnerraumschiff hinzugefügt. Die Schüsse die das Gegnerschiff abgibt treffen mich nur dann wen ich mich voher bewegt habe, wenn ich aber an einer Stelle verharre und das Schiff dann feuert geht der Schuss durch mich durch. Ich hoffe das es an der Kollisionsabfrage liegt und ich zurzeit einfach nur zu dämlich bin den Fehler zu finden.


Gegner.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
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


Gegner.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
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;

    }
}


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


Game.cpp (Nur die Kollisionsabfrage)
Ich denke das der Fehler höchstwahrscheinlich in der Kollisionsabfrage liegt

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


Shot.cpp(Nur die Veränderungen für meinen Gegnerschuss)

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)

Phalax

Frischling

Beiträge: 82

Beruf: Student Media Systems

  • Private Nachricht senden

2

18.03.2011, 19:21

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.

Chris13

Frischling

  • »Chris13« ist der Autor dieses Themas

Beiträge: 73

  • Private Nachricht senden

3

18.03.2011, 20:01

Zitat von »Phalax«

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.


Danke schonmal für die Tipps :)

Zu 1: Hast vollkommen Recht ich tuh mich da nur etwas schwer kommt hoffendlich mit der Zeit noch das ich in einer Sprache bleibe^^.

Zu 2: Float ist absichtlich gewählt, später wird es verschiedene Attacken geben die wiederum verschiedene Kritische Chancen haben und so auch verschieden Schaden machen. Muss das ganze später noch überarbeiten. Zuerst baue ich mir nur ein Grundteil auf, auf dem ich Später aufbaue :).

Zu 3: Jupp gute Idee :)

So den Fehler habe ich jetzt behoben, bin auch manchmal blöd :D
Und zwar habe ich für die Gesamt Position des Schusses je etwas dazugerechnet damit es am Unterenteil genau in der Mitte abgeschossen wird. Dieses habe ich allerdings nicht in der Kollisionsabfrage mit einberechnet und so kamm es, dass er es manchmal einfach durchflogen hat, da ich es nicht dazu gerechnet habe.
Bin ich froh das ich selbst drauf gekommen bin.(Hey ich hab schon Raketen in meinem Spiel ;) )

Verbessertes:

Shot.cpp u. 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

#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)


Die Kollisionsabfrage(Verbessert)

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)

Phalax

Frischling

Beiträge: 82

Beruf: Student Media Systems

  • Private Nachricht senden

4

18.03.2011, 21:07

Zitat

void CShot::Render (float m_fMitteln, float m_fUnten)

m_ sollte eigentlich zum Kenntlich machen 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.

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »Phalax« (18.03.2011, 21:15)

Chris13

Frischling

  • »Chris13« ist der Autor dieses Themas

Beiträge: 73

  • Private Nachricht senden

5

18.03.2011, 21:12

Zitat von »Phalax«

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.


Danke :) Ist mir garnicht aufgefallen. Nein ich finde es gut das du es gesagt hast kann nur helfen.

TigerClaw25

unregistriert

6

17.04.2013, 11:22

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.

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »TigerClaw25« (17.04.2013, 11:45)

tomgames

Frischling

Beiträge: 45

  • Private Nachricht senden

7

17.04.2013, 13:37

Zitat von »TigerClaw25«

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.



Manchmal sieht man den Wald vor lauter Bäumen nicht.... ;)
'=' ist nicht '=='
Die besten Grüsse

Thomas

Mutant3D Basic
www.tcspiele.de

BlueCobold

Community-Fossil

Beiträge: 10 738

Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer

  • Private Nachricht senden

8

17.04.2013, 13:41

Zudem ist das Topic von 2011 und hat mit dem Problem von TigerClaw nichts zu tun. Damit schließe ich dieses Thema nun auch. Es wurde ihm schon oft genug geraten einen Debugger zu benutzen und da wäre dann auch aufgefallen, dass der Wert von RectOpponent.x sich nach der If-Abfrage (eher wohl eine Zuweisung mit Abfrage) geändert hat.
Teamleiter von Rickety Racquet (ehemals das "Foren-Projekt") und von Marble Theory

Willkommen auf SPPRO, auch dir wird man zu Unity oder zur Unreal-Engine raten, ganz bestimmt.[/Sarkasmus]

Werbeanzeige

Ähnliche Themen