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

Werbeanzeige

Abcd1234

Treue Seele

  • »Abcd1234« ist der Autor dieses Themas

Beiträge: 113

  • Private Nachricht senden

1

28.06.2008, 10:39

SDL Parachute Deployed

Hi,

Ich bekomme immer eine SDL Konsolen Fehlermeldung, wenn ich versuche Funktionen einer bestimten Klasse aufzurufen.

FOllgende Meldung: Fatal Signal: Segmentation Fault <SDL Parachute Deployed>

Ich habe das Gefühl das es etwas mit den Load und Renderfunktionen meiner Grafiken zutun hat bin mir aber auch nicht ganz sicher..

Hier mal etwas Quellcode

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
178

#ifndef FIRESHOT_HPP
#define FIRESHOT_HPP

#include "Player.hpp"
#include "Sprite.hpp"
#include "Framework.hpp"
#include "timer.hpp"

class CFireShot
{

public:

    CFireShot ();
    void Update (CPlayer Player);
    int ReturnXLeft ();
    int ReturnXRight ();
    int ReturnYDown ();
    int ReturnYUP ();
    void ShotReturn ();
    void Render (CPlayer Player);

private:

    float m_fAreaDown;
    float m_fAreaUp;
    float m_fAreaLeft;
    float m_fAreaRight;
    bool m_bShotON;
    bool m_bShotInit;
    int m_ShotDirection;
    int m_Status;
    float m_fMaxmovement;



    CSprite *m_FireGrafic;
    int  m_Rendermodus;
    float m_fRendetime;


};

#endif

//Ubdate

//

//Aufgabe: Schuß Ubdaten

//

void CFireShot::Update(CPlayer Player)
{

    if (Player.ShotReturn() == true)
    {
        if( m_bShotInit == false)
        {
            //Abfrage nach Blickrichtung

            if(Player.FaceDirectionRueckgabe() == 1)
            {
                //Schuß nach Links ist an

                m_ShotDirection = 1;
                //Startposition an Spieler anpassen

                m_fAreaLeft = Player.AreaLeftRueckgabe();
                m_fAreaUp = Player.AreaUPRueckgabe()+15;
                

            }
            else
            {
                //Schuß nach Rechts ist an

                m_ShotDirection = 2;
                //Startposition an Spieler anpassen

                m_fAreaLeft = Player.AreaRightRueckgabe();
                m_fAreaUp = Player.AreaUPRueckgabe()+15;


            }

            m_bShotInit = true;
            m_bShotON = true;
            m_Status = 1;
            m_FireGrafic->Load_MoveObject("Data\Grafics\Player\Fire.bmp", 16, 16);

        }

        //Abfragen ob Schußbewegung ihr Ende ereicht

        if (m_fMaxmovement >= 400)
        {
            //Schußendsequenz ist on

            m_Status = 2;

            //Werte wieder zurücksetzen

            m_fRendetime = 0;
            m_Rendermodus = 0;
            m_FireGrafic->Load_MoveObject("Data\Grafics\Player\FireEnd.bmp", 10, 9);
        }

        //Abfrage ob der SChuß noch fliegen soll

        if (m_Status == 1)
        {

            //Nach Schußrichtung abfregen

            if(m_ShotDirection == 1)
            {
                //Bewegungen ubdaten

                
                //Pixelbewegung speichern

                m_fMaxmovement += 400 * g_pTimer->GetElapsed ();


                m_fAreaLeft += 400 * g_pTimer->GetElapsed ();
                m_fAreaRight = m_fAreaLeft + 10;
                m_fAreaDown += 150 * g_pTimer->GetElapsed ();
                m_fAreaUp = m_fAreaDown-9;

            }
            else
            {
                //Pixelbewegung speichern

                m_fMaxmovement += 400 * g_pTimer->GetElapsed ();


                //Bewegungen ubdaten

                m_fAreaLeft -= 400 * g_pTimer->GetElapsed ();
                m_fAreaRight = m_fAreaLeft + 10;
                m_fAreaDown += 150 * g_pTimer->GetElapsed ();
                m_fAreaUp = m_fAreaDown-9;

            }

            //Renderzeit erhöhen damit andere Renderteile aufgerufen werden

            m_fRendetime += 1 * g_pTimer->GetElapsed ();
            
            //Abfrage nach der Renderzeit und entsprechendes Bild  Rendern

            if (m_fRendetime < 0.2)
            {
                m_Rendermodus = 0;
            }
            else if (m_fRendetime >= 0.2)
            {
                m_Rendermodus = 1;
            }
            else if(m_fRendetime < 0.4)
            {
                m_Rendermodus = 2;
                m_fRendetime = 0;
            }

        }
        //Wenn nicht Schuß neigt sich dem Ende zu Rauchanimation

        else
        {
            m_fRendetime += 1 * g_pTimer->GetElapsed ();
            
            if (m_fRendetime < 0.2)
            {
                m_Rendermodus = 0;
            }
            else if (m_fRendetime >= 0.2)
            {
                m_Rendermodus = 1;
            }
            else if(m_fRendetime < 0.4)
            {
                m_fRendetime = 0;
                m_bShotInit = false;
                m_bShotON = false;
                //Schuß ist wieder erlaubt

                Player.ShotAnpassen();
            }


        }


    }

}


In den Quellcode oberen Codeausschnitt befindet sich einmal der Header und eine der FUnktionen die Probleme macht.

Hat jemand eine Idee was da schieß läuft? Hatte schonmal das Problem und konnte es irgendwie umgehen bin mir aber nicht mehr sicher wie..

Ich hoffe jemand kann Helfen :)

Gruß Abcd

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

2

28.06.2008, 10:46

Soll das ein Witz sein?
Wie soll dir da jemand helfen können?
In dem Code ist kein einziger SDL-Aufruf drin, und woher sollen wir wissen, wie du deine ganzen Methoden/Funktionen definiert hast?
David Scherfgens Website | Konzentrationstest Polizei

Abcd1234

Treue Seele

  • »Abcd1234« ist der Autor dieses Themas

Beiträge: 113

  • Private Nachricht senden

3

28.06.2008, 11:13

Wie gesagt bin ich recht hilflos bei diesem Problem, weil sich der Debugger ziemlich komischer verhält und ich mir selber überhaupt nicht erklären kann woran es liegt ich Poste daher mal die Render und Load Funktionen, wo SDL aufrufe drinne sind:

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

    // Render_MoveObject

    //

    // Aufgabe: Rendern eines bewegten Objekts und Abfragen ob und wo er gerendert werden soll ------> Es werden nur einzeilige Animationslisten unterstützt!!!

    //

    void CSprite::Render_MoveObject (float fFrameNumber, int XScreenMin, int XScreenMax, int YScreenMin, int YScreenMax,  int X1, int Y1 )
    {
        //Momentanes Animationsbild ansteuern

        m_FrameRect.x = fFrameNumber * m_FrameWidth;
        m_FrameRect.y = 0;

        //Hoehe bestimmen


        int PlayerXScreenMin = XScreenMin;  // Linkes Bildschirmende

        int PlayerXScreenMax = XScreenMax;  // Rechtes Bildschirmende


        int PlayerYScreenMin = YScreenMin; //Oberes Bildschirmende

        int PlayerYScreenMax = YScreenMax;  //Unteres Bildschirmende


        int EnemyXLeft = X1;    // Linker X Wert des Gegner Bildes

        int EnemyXRight = X1 + m_FrameWidth;    // Rechter X Wert des Gegner Bildes


        int EnemyYDown = Y1;    //Unterer Y Wert des Bildes

        int EnemyYUp = Y1 - m_FrameHeight; //Oberer Y Wert des Bildes

;

        
        //Abfrage ob sich Gegner im Y Bereich des Spielers befindet

        if (PlayerYScreenMax > EnemyYUp && PlayerYScreenMin < EnemyYDown)
        {
            //Wenn ja -> Abfrage ob oben nur ein Teil im Y Bereich ist

            if (PlayerYScreenMin > EnemyYUp)
            {
                //Position ab dem der Animationsteil beginnt erhöhen

                m_FrameRect.y = PlayerYScreenMin-EnemyYUp;
                
                //Animationsteil kleiner machen

                m_FrameRect.h = EnemyYDown - PlayerYScreenMin;

                //Bild soll ganz oben angezeigt werden

                m_Rect.y = 0;

                //Speichern das Gegner im Y Bereich des Screens ist

                m_bYArea = true;
    

            }
            //Wenn nein -> Abfrage ob unten nur ein Teil im Y Bereich ist

            else if (PlayerYScreenMax < EnemyYDown)
            {

                //Animationsteil kleiner machen

                m_FrameRect.h = PlayerYScreenMax - EnemyYUp;

                //Bestimmen wo das BIld zu sehen sein soll

                m_Rect.y = EnemyYUp - PlayerYScreenMin;


                //Speichern das Gegner im Y Bereich des Screens ist

                m_bYArea = true;

            }
            //Wenn nein -> Gegner ist ganz im Y Bereich

            else 
            {

                //Stelle bestimmen, wo das Bild gerendert wird

                m_Rect.y = EnemyYUp-PlayerYScreenMin;
                
                //Hoehe des Animationsbildes

                m_FrameRect.h = EnemyYDown-EnemyYUp;

                //Speichern das Gegner im Y Bereich des Screens ist

                m_bYArea = true;



            }

        }



        //cout << "Gegner Links Koordinate: " << EnemyXLeft << " Gegner Rechts Koordinate: " << EnemyXRight << endl; 

        //cout << "Player Min Screen: " << PlayerScreenMin << " Player Max Screen: " << PlayerScreenMax << endl;


        //Abfrage ob sich Gegner im X Bereich des Spielers befindet

        if (PlayerXScreenMax > EnemyXLeft && PlayerXScreenMin < EnemyXRight)
        {   
            //Wenn ja -> Abfrage ob links nur ein Teil im X Bereich ist

            if (PlayerXScreenMin > EnemyXLeft)
            {   
                //Position ab dem der Animationsteil beginnt erhöhen

                m_FrameRect.x += PlayerXScreenMin - EnemyXLeft;
                
                //Und Animationsteil kleiner machen

                m_FrameRect.w = EnemyXRight - PlayerXScreenMin;
                
                //Bild wird links angezeigt

                m_Rect.x = 0;
                
                //Speichern das Gegner im X Bereich des Screens ist

                m_bXArea = true;
            }
            //Wenn Nein -> Fragen ob es evtl. Rechts nur zum Teil im X Bereich ist

            else if (PlayerXScreenMax < EnemyXRight)
            {
                //Bestimt wo das Bild rechts gerendert werden soll

                m_Rect.x = EnemyXLeft - PlayerXScreenMin;
                
                //Bestimt die Breite die gerednert wird

                m_FrameRect.w =  PlayerXScreenMax - EnemyXLeft;
                
                //Speichern das Gegner im X Bereich des Screens ist

                m_bXArea = true;

            }
            //Wenn Nein -> Gegner ist "ganz"  im X Bereich des Spielers

            else
            {
                //Position wo das Bild angezeigt wird

                m_Rect.x = EnemyXLeft-PlayerXScreenMin;
                
                //Maximale Breite wird angezeigt, da Bild ganz zu sehen ist

                m_FrameRect.w = EnemyXRight - EnemyXLeft;
                
                //Speichern das Gegner im X Bereich des Screens ist

                m_bXArea = true;

            }
        }
    

        // Ausschnitt rendern wenn er sich im X und Y Bereich des Spielers befindet "also im Sichtbereich"

        if (m_bXArea == true && m_bYArea == true)
        {

            SDL_BlitSurface (m_pImage, &m_FrameRect, m_pScreen, &m_Rect);
            m_bXArea = false;
            m_bYArea = false;
        }
        

    }

// Load

//

// Aufgabe: Animiertes Sprite laden

//

void CSprite::Load_MoveObject (const string sFilename, int FrameWidth, int FrameHeight)
{
  // Bitmap laden

  Load (sFilename);

  // Rect für Animationsphase initialisieren

  m_FrameWidth  = FrameWidth;
  m_FrameHeight = FrameHeight;
  m_FrameRect.w = FrameWidth;
  m_FrameRect.h = FrameHeight;

} // Load


Hier sind jetzt die FUnktionen die in der problematischen Funktion aufgerufen werden.

bwbg

Treue Seele

Beiträge: 107

  • Private Nachricht senden

4

28.06.2008, 12:26

Auch hier hilft die Kristallkugel nicht wirklich weiter. Auch im zweiten Post sind Funktions- oder Methodenaufrufe, welche nicht weiter erläutert sind.

Zitat

Quellcode

 
1

Load(xyz)


Möglicherweise (das Klassendesign lässt darauf schließen) verwendest du deine Sprite-Klasse ebenfalls zur Resourceverwaltung. Das erkennst du daran, dass

1. du Deine Grafiken im Konstruktor oder durch eine Methode lädst und diese in einem SDL_Surface* (<- POINTER) Attribut unterbringst.

und du

2. einen Destruktor definiert hast, welcher die Grafik mittels SDL_FreeSurface wieder freigibt.

Verwendest du dieses Konstrukt, dann knallt es zwangsläufig.

Prüfe das und grenze das Problem besser ein! Mit Debugger oder notfalls mit std::clog um die Funktions-/Methodenaufrufe.

Grüße... Heiko

Abcd1234

Treue Seele

  • »Abcd1234« ist der Autor dieses Themas

Beiträge: 113

  • Private Nachricht senden

5

28.06.2008, 14:32

Ich glaube ich verwende das angesprochene Kosntrukt:

Die Sprites werden durch follgende Funktion geladen:

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

// Load

//

// Aufgabe: Einfaches, nicht animiertes Sprite laden

//

void CSprite::Load (const string sFilename)
{
  // Bitmap laden

  m_pImage = SDL_LoadBMP (sFilename.c_str());

  // Prüfen, ob alles glatt ging

  if (m_pImage == NULL)
  {
    cout << "Fehler beim Laden von: " << sFilename.c_str();
    cout << endl;
    cout << "Fehlermeldung: " << SDL_GetError () << endl;

    // Framework herunterfahren

    g_pFramework->Quit ();

    // Gesamtes Spiel beenden

    exit (1);
  }


Und hier ist dann der Destruktor:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10

// Destruktor

//

// Aufgabe: Surface des Sprites freigeben

//

CSprite::~CSprite ()
{
  // Surface freigeben

  SDL_FreeSurface (m_pImage);

} // Destruktor


Aber wieso soll das so Problematisch sein?

drakon

Supermoderator

Beiträge: 6 513

Wohnort: Schweiz

Beruf: Entrepreneur

  • Private Nachricht senden

6

28.06.2008, 14:40

Mal so am Rande.

C-/C++-Quelltext

 
1

    void Update (CPlayer Player);


Warum übergibst du das da per Kopie?. Das könnte ein Problem geben, weil du da Player kopierst, wahrscheinlich keine copy-ctor hast und das Objekt am Schluss gelöscht wird. Somit wird der Zeiger auch freigeben. (Vermute ich mal, dass es hier liegt).

C-/C++-Quelltext

 
1

    void Update (CPlayer const & Player);


Ne const Referenz bringt dir da mehr.
http://www.drakon.ch | Weltweit 31. Bester Solitär Spieler (Standard XP)

Abcd1234

Treue Seele

  • »Abcd1234« ist der Autor dieses Themas

Beiträge: 113

  • Private Nachricht senden

7

28.06.2008, 14:56

Vielen Dank :)

Genau das war hier das Problem. Es läuft wieder.

Werbeanzeige