[C++ - SDL] Une condition mal évaluée

**<Zer0>** · 16/09/2007, 16h11

Salut !

Le problème exposé plus loin provient sans doute d'une erreur de "C++" de ma part, et non d'une erreur de "SDL". Mais vu la quantité de code SDL je préfère poster ici pour que tout le monde comprenne.

Je commence à coder un RPG 2D depuis quelques jours, mais je suis confronté à un problème incompréhensible. Mon jeu fonctionnait parfaitement, mais voyant qu'il grossissait rapidement, j'ai voulu partager un fichier en deux en leur faisant partager une en-tête commune, mais à partir de là le jeu n'a plus fonctionné comme avant (il n'y a aucun message d'erreur).

Il s'agit donc d'un personnage nommé idiomatiquement "link" qu se déplace sur une carte de (17*17)*32, chaques sprites de décors faisant 32*32 et étant défini par une chaîne de caractères. Il est sensé se déplacer normalement sur les terrains " " et "h", mais il doit être bloqué devant un terrain "H".

Le personnage est géré par la classe Warrior située dans le fichier warrior.cpp, et le terrain par la classe Field stockée dans le fichier field.cpp. Les deux fichiers partagent l'en-tête header.h, qui déclare les classes susnommées.
Le terrain, stocké dans le champ map de la classe Field, contient le contenu d'une variable globale nommée maptest, définissant la carte (avec le système des " ", "h" et "H").

Lors d'un déplacement, la fonction membre getMap() de la classe Field est appellée depuis la fonction membre move() de la classe Warrior, afin de savoir devant quel type de terrain se trouve link. Le troisième argument de getMap vaut soit 0 soit 1, auquel cas les messages de débogages apparaissent sur le fichier de sortie.

Voici la condition posant problème (je montre ici celle executée lors d'un déplacement vers le haut à titre d'exemple). Elle vérifie si link ne se trouve pas devant une salade (terrain "H") à gauche puis à droite.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
if((field.getMap((int)gy/32, (int)gx/32, 0) != "H") && (field.getMap((int)dy/32, (int)dx/32, 0) != "H")) /* Le probleme vient du fait que la condition est toujours consideree comme etanat vraie... */
{
  /* messages de débogage */
  std::cout << "On a a gauche : " << field.getMap((int)gy/32, (int)gx/32, 0);
  std::cout << ", et a droite : " << field.getMap((int)dy/32, (int)dx/32, 0) << "." << std::endl;
  std::cout << "-----------------" << std::endl;
 
  pos.y -= 2;
}

Les messages de débogages affichent donc parfois des trucs du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
On a a gauche : H, et a droite :  .
-----------

Ce qui signifie qu'on a une salade à gauche et un terrain vide à droite. Cela est complètement illogique puisque la condition ne s'execute que si aucune salade n'est présente à droite et à gauche... Je me permets par ailleurs d'insister lourdement sur le fait que cela fonctionnait correctement avant que je sépare les définitions de classe Warrior et Field (qui étaient avant définies toutes deux dans un classes.cpp), et que le problème ne vient donc pas des calculs.

Voici donc le code complet, qui est grand pour moi, mais sans doute tout petit pour vous

.

header.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#include <iostream>
#include <cstring>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
 
class Warrior;
class Field;
 
class Warrior
{
    public:
        Warrior();
 
        Warrior& move(SDL_Event event, Field field);
        Warrior& stop(SDL_Event event);
 
        SDL_Rect getPos();
        SDL_Rect getSize();
 
        SDL_Surface* getSurface();
    private:
        SDL_Rect pos;
        SDL_Rect size;
        SDL_Surface* surf;
 
        long temps_ecoule;
        long dernier_temps;
};
 
class Field
{
    public:
        Field();
 
        const char* getMap(int x, int y, int c = 0);
        SDL_Surface* getField();
    private:
        char* map[17][17]; /* 17x17 */
        SDL_Surface* fields;
};

main.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#include "header.h"
 
int main ( int argc, char** argv )
{
    bool done;
 
    SDL_Init(SDL_INIT_VIDEO);
    SDL_EnableKeyRepeat(10, 10);
    atexit(SDL_Quit);
 
    SDL_Surface *ecran = SDL_SetVideoMode(544, 544, 16, SDL_HWSURFACE|SDL_DOUBLEBUF);
 
    SDL_Rect fPos, fSize;
    fSize.w = 32; fSize.h = 32;
 
    Warrior link = Warrior();
    Field f = Field();
 
    done = false;
    while (!done)
    {
        SDL_Event event;
        while (SDL_PollEvent(&event))
        {
            switch (event.type)
            {
                case SDL_QUIT:
                    done = true;
                    break;
                case SDL_KEYDOWN:
                {
                    switch(event.key.keysym.sym)
                    {
                        case SDLK_ESCAPE:
                        done = true;
                        break;
 
                        case SDLK_UP:
                        case SDLK_RIGHT:
                        case SDLK_DOWN:
                        case SDLK_LEFT:
                        link.move(event,f);
                        break;
                    }
                    break;
                }
                case SDL_KEYUP:
                {
                    switch(event.key.keysym.sym)
                    {
                        case SDLK_UP:
                        case SDLK_RIGHT:
                        case SDLK_DOWN:
                        case SDLK_LEFT:
                        link.stop(event);
                        break;
                    }
                    break;
                }
            }
        }
        SDL_FillRect(ecran, 0, SDL_MapRGB(ecran->format, 255, 255, 255));
 
        for(int y = 0; y < 544; y += 32)
        {
            for(int x = 0; x < 544; x += 32)
            {
                fPos.y = y;
                fPos.x = x;
 
                if( !strcmp(f.getMap(y/32, x/32), " "))
                {
                    fSize.x = 0; fSize.y = 0;
                    SDL_BlitSurface(f.getField(), &fSize, ecran, &fPos);
                }
                if( !strcmp(f.getMap(y/32, x/32), "H"))
                {
                    fSize.x = 32; fSize.y = 0;
                    SDL_BlitSurface(f.getField(), &fSize, ecran, &fPos);
                }
                if( !strcmp(f.getMap(y/32, x/32), "h"))
                {
                    fSize.x = 64; fSize.y = 0;
                    SDL_BlitSurface(f.getField(), &fSize, ecran, &fPos);
                }
            }
        }
 
        SDL_BlitSurface(link.getSurface(), &link.getSize(), ecran, &link.getPos());
 
        SDL_Flip(ecran);
    }
 
    std::cout << "Exited correctly." << std::endl;
 
    return 0;
}

field.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#include "header.h"
 
char* maptest[17][17] = {
    {" ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "},
    {" ", "h", "h", "h", "h", "h", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "},
    {" ", "h", "h", "H", "H", "h", "h", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "},
    {" ", "h", "h", "H", "H", "h", "h", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "},
    {" ", "h", "h", "H", "H", "h", "h", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "},
    {" ", "h", "h", "h", "h", "h", "h", " ", " ", " ", " ", "h", "h", "h", " ", " ", " "},
    {" ", "h", "h", "h", "h", "h", "h", " ", " ", " ", " ", "h", "h", "h", " ", " ", " "},
    {" ", "h", "h", "h", "H", "H", "h", " ", " ", " ", " ", " ", "h", "h", " ", " ", " "},
    {" ", "h", "h", "h", "H", "H", "h", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "},
    {" ", "h", "h", "h", "h", "h", "h", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "},
    {" ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "},
    {" ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "},
    {" ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "},
    {" ", " ", " ", " ", " ", " ", " ", " ", " ", " ", "h", "h", "h", "h", "h", " ", " "},
    {" ", " ", " ", " ", " ", " ", " ", " ", " ", " ", "h", "H", "H", "H", "h", " ", " "},
    {" ", " ", " ", " ", " ", " ", " ", " ", " ", " ", "h", "H", "H", "H", "h", " ", " "},
    {" ", " ", " ", " ", " ", " ", " ", " ", " ", " ", "h", "H", "H", "H", "h", " ", " "}
};
 
Field::Field()
{
    fields = IMG_Load("../img/terrain.gif");
 
    for(int j=0; j < 17; ++j)
    {
        for(int i=0; i < 17; ++i)
        {
            map[j][i] = maptest[j][i];
        }
    }
}
 
const char* Field::getMap(int y, int x, int c)
{
    if (c==1)
    {
        std::cout << "Les arguments sont : y = " << y << ", x = " << x << "." << std::endl;
        std::cout << "On retourne : " << map[y][x] << "." << std::endl;
    }
 
    return map[y][x];
}
 
SDL_Surface* Field::getField()
{
    return fields;
}

warrior.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#include "header.h"
 
Warrior::Warrior()
{
    pos.x = 544/2 - 30/2; /* 272 + 15 */
    pos.y = 544/2 - 32/2; /* 272 + 16 */
 
    size.x = 0;
    size.y = 0;
    size.w = 29;
    size.h = 32;
 
    surf = IMG_Load("../img/link.gif");
 
    temps_ecoule = SDL_GetTicks();
    dernier_temps = temps_ecoule;
}
 
/* ------------------------- Warrior::deplacement --------------------------- */
 
Warrior& Warrior::move(SDL_Event event, Field field)
{
    double gx, gy, dx, dy;
 
    temps_ecoule = SDL_GetTicks();
    if(event.type == SDL_KEYDOWN)
    {
        switch(event.key.keysym.sym)
        {
            case SDLK_UP: /* c'est cette condition que je débogue (j'aurais pu en choisir une autre) */
            {
                gx = pos.x;
                gy = pos.y; /* -2 ? */
                dx = pos.x + 30;
                dy = pos.y; /* -2 ? */
 
                if((field.getMap((int)gy/32, (int)gx/32, 0) != "H") && (field.getMap((int)dy/32, (int)dx/32, 0) != "H")) /* Le probleme vient du fait que la condition est toujours consideree comme etanat vraie... */
                {
                    std::cout << "On a a gauche : " << field.getMap((int)gy/32, (int)gx/32, 0);
                    std::cout << ", et a droite : " << field.getMap((int)dy/32, (int)dx/32, 0) << "." << std::endl;
                    std::cout << "-----------------" << std::endl;
                    pos.y -= 2;
                }
                else
                {
                    std::cout<<"COLLISION !!"<<std::endl;
                }
                if(temps_ecoule - dernier_temps > 150)
                {
                    size.x == 120?size.x = 150:size.x=120;
                    dernier_temps = temps_ecoule;
                }
                break;
            }
            case SDLK_RIGHT:
            {
                gx = pos.x + +28; /* +2 ? */
                gy = pos.y;
                dx = pos.x + 28; /* +2 ? */
                dy = pos.y + 32;
 
                if((field.getMap((int)gy/32, (int)gx/32) != "H") && (field.getMap((int)dy/32, (int)dx/32) != "H"))
                {
                    pos.x += 2;
                }
                if(temps_ecoule - dernier_temps > 150)
                {
                    size.x == 240?size.x = 270:size.x=240;
                    dernier_temps = temps_ecoule;
                }
                break;
            }
            case SDLK_LEFT:
            {
                gx = pos.x; /* -2 ? */
                gy = pos.y;
                dx = pos.x; /* -2 ? */
                dy = pos.y + 32;
 
                if((field.getMap((int)gy/32, (int)gx/32) != "H") && (field.getMap((int)dy/32, (int)dx/32) != "H"))
                {
                    pos.x -= 2;
                }
                if(temps_ecoule - dernier_temps > 150)
                {
                    size.x == 180?size.x = 210:size.x=180;
                    dernier_temps = temps_ecoule;
                }
                break;
            }
            case SDLK_DOWN:
            {
                gx = pos.x;
                gy = pos.y + 30; /* +2 ? */
                dx = pos.x + 30;
                dy = pos.y +30; /* +2 ?*/
 
                if((field.getMap((int)gy/32, (int)gx/32) != "H") && (field.getMap((int)dy/32, (int)dx/32) != "H"))
                {
                    pos.y += 2;
                }
                if(temps_ecoule - dernier_temps > 150)
                {
                    size.x == 30?size.x = 60:size.x=30;
                    dernier_temps = temps_ecoule;
                }
                break;
            }
        }
    }
    else
    {
        std::cerr << "Erreur incomprehensible... Argument event n'etait pas du type attendu." << std::endl;
    }
    return *this;
}
Warrior& Warrior::stop(SDL_Event event)
{
    if(event.type == SDL_KEYUP)
    {
        switch(event.key.keysym.sym)
        {
            case SDLK_UP:
            {
                size.x = 90;
                break;
            }
            case SDLK_RIGHT:
            {
                size.x = 240;
                break;
            }
            case SDLK_LEFT:
            {
                size.x = 180;
                break;
            }
            case SDLK_DOWN:
            {
                size.x = 0;
                break;
            }
        }
    }
    else
    {
        std::cerr << "Erreur incomprehensible... Argument event n'etait pas du type attendu." << std::endl;
    }
    return *this;
}
 
/* ---------------------------- Warrior::Image ------------------------------ */
 
SDL_Rect Warrior::getPos()
{
    return pos;
}
SDL_Rect Warrior::getSize()
{
    return size;
}
 
SDL_Surface* Warrior::getSurface()
{
    return surf;
}

Voilà-voilà. Je connais bien mon code (normal) donc il y a dest trucs que j'ai peut-être omis d'expliquer, n'hésitez pas à me le faire remarquer.

En espérant que vous puissiez m'aider.

**droggo** · 16/09/2007, 17h13

Lio,

Tu sembles vouloir comparer des chaînes de caractères (délimiteur ") en utilisant un simple test !=.

Or, quand en C ou C++ tu fais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

chaine1 != chaine2;

tu compares les adresses des 2 chaînes, pas leur contenu.

Il faut utiliser strcmp, ou l'équivalent de ta librairie, si tu en utilises une.

**<Zer0>** · 16/09/2007, 17h17

Ah, c'est exact. C'est le genre de truc auquel je ne pense jamais

.
Pourtant comme cela fonctionnait avant cela serait étrange que ce soit ça.
Je teste et je confirme (ou non)

**Laurent Gomila** · 16/09/2007, 17h18

J'ai presque rien lu, parce que ça me semble très long comme explication pour un petit problème

J'ai l'impression que tu compares deux char*. Si c'est le cas cela va comparer des adresses (char* est un pointeur, c'est-à-dire une adresse mémoire), et forcément elles seront toujours différentes. Si tu veux comparer les chaînes pointées, il faut utiliser strcmp (en C) ou std::string (en C++).

Ou encore mieux : utilise des caractères plutôt que des chaînes ('H' au lieu de "H", et char au lieu de char*), puisqu'a priori tu n'as jamais plus d'un d'un caractère par case.

**<Zer0>** · 16/09/2007, 17h40

@Laurent Gomila : En effet je ne compte pas avoir plus d'un caractère par case. J'aurais dû y penser plus tôt >_< ... Enfin sait-on jamais, je vais laisser comme ça au cas où.

En effet, le problème venait de la comparaison des chaînes. Après avoir déjà buté sur ce problème vers la fin du main.cpp, et même aider certaines personnes moi-même face à ce problème, je n'ai toujours pas retenu la leçon... Y'a de quoi déprimer.
Je ne comprend pas toutefois pourquoi cela fonctionnait correctement avant ?

Je vous remercie beaucoup

**fearyourself** · 17/09/2007, 09h45

Envoyé par <Zer0>

Je ne comprend pas toutefois pourquoi cela fonctionnait correctement avant ?

Vu que ton code utilise souvent la même chaîne "H", le compilateur optimise la zone mémoire afin d'utiliser une seule chaîne "H" en mémoire et tous les pointeurs seront dessus.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
  char *s1 = "Hello world!",
         *s2 = "Hello world!";
 
  printf("%p -> %s\n", s1, s1);
  printf("%p -> %s\n", s2, s2);
  return EXIT_SUCCESS;
}

me retourne ceci :

0x80484ac -> Hello world!
0x80484ac -> Hello world!

Par contre, si on sépare les deux chaînes de caractères dans deux fichiers différents :

hello1.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
#include <stdio.h>
 
void hello1(void)
{
   char *s1 = "Hello world!";
   printf("%p -> %s\n", s1, s1);
}

hello2.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
#include <stdio.h>
 
void hello2(void)
{
   char *s2 = "Hello world!";
   printf("%p -> %s\n", s2, s2);
}

et on appelle ceci dans un fichier main.c séparé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
#include <stdio.h>
#include <stdlib.h>
 
extern void hello1(void);
extern void hello2(void);
int main(void)
{
    hello1();
    hello2();
    return EXIT_SUCCESS;
}

alors le compilateur ne va pas pouvoir optimiser aussi facilement :

0x80484cc -> Hello world!
0x80484e3 -> Hello world!

d'où le fait qu'il faut utiliser strcmp pour faire une comparaison de chaîne de caractères...

Remarque : par contre, si on compile en -O3, on va retrouver ceci :

0x80484cc -> Hello world!
0x80484cc -> Hello world!

Jc