Problème sur le tutorial mouvement du sprite

Version imprimable

22/01/2009, 22h47
Nothingness0x

Problème sur le tutorial mouvement du sprite

Bonjour,

J'ai suivi le tutorial de loka sur SDL, et j'ai un gros problème sur le chapitre X sur le mouvement du sprite, en gros j'ai recodé à ma sauce (c'est à dire en séparant les classes avec un header et un autre fichier cpp), mais tout en respectant le code de l'auteur.

Et malgré cela le sprite ne bouge pas lorsque je reste appuyé sur une touche du clavier, en gros l'évenement ne se déclanche que lorsque j'appuie sur la touche, coup par coup.

Je ne comprends absolument pas d'où cela vien car j'ai réutilisé globalement le même code.

Mais je dois avouer que je n'ai pas réussi à comprendre comment ça marche le sprite qui avance lorsque l'on reste appuyé sans utiliser SDL_EnableKeyRepeat.

Svp si quelqu'un qui connais le tutorial pouvait m'aider ce serait simpa ...

ps : Je ne sais pas comment poster les fichiers source de mon projet, ce qui devrait pouvoir vous aidez à m'aider. Il comporte deux cpp et un header.
Si vous me demander et me dites comment le poster je le ferais bien entendu.

Merci.
23/01/2009, 00h33
LittleWhite

Pour montrer le code source il y a deux méthodes :

Sois tu ouvre une balise [ C O D E ] [ / C O D E ] ( sans les espaces ) ( bouton # en haut lorsque tu post ). Soit tu ajoute des fichiers joints grace à l'option en dessous de la zone pour poster.

je pense que ton problème vient de la fonction "handle_input()"
Si tu veux que l'on jette un coup d'oeil dessus utilise les balises [ C O D E ] et copie ton code qui gère l'appuie des touches entre les balises.
Je pense que tu as fait une petite erreur lors de la recopie. Un truc idiot que l'on ne voit pas tout de suite ;) ( comme beaucoup d'erreur )

Ok je pense aussi que le problème venais de cette fonction mais je l'ai verifié pas mal de fois. Le problème c'est que je comprends vraiment pas en quoi cette fonction remplace un SDL_EnableKeyRepeat ... j'arrive pas à la comprendre, enfin bref je te poste la fonction :

Code:

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
 void Point::handle_input(SDL_Event event, SDL_Surface* affichePoint,SDL_Surface* screen)
{
 
 
    if( event.type == SDL_KEYDOWN )
    {
        //ajustement de la vitesse
        switch( event.key.keysym.sym )
        {
            case SDLK_UP: yVel -= POINT_HEIGHT / 2; break;
            case SDLK_DOWN: yVel += POINT_HEIGHT / 2; break;
            case SDLK_LEFT: xVel -= POINT_WIDTH / 2; break;
            case SDLK_RIGHT: xVel += POINT_WIDTH / 2; break;
            default: break;
        }
    }
    //Si une touche a ete relachee
    else if( event.type == SDL_KEYUP )
    {
        //ajustement de la vitesse
        switch( event.key.keysym.sym )
        {
            case SDLK_UP: yVel += POINT_HEIGHT / 2; break;
            case SDLK_DOWN: yVel -= POINT_HEIGHT / 2; break;
            case SDLK_LEFT: xVel += POINT_WIDTH / 2; break;
            case SDLK_RIGHT: xVel -= POINT_WIDTH / 2; break;
            default: break;
        }
    }
    show(affichePoint, screen);
}
 
 
 
void Point::show(SDL_Surface* source, SDL_Surface* destination)
{
    SDL_Rect offset;
    //Bouge le point à gauche ou à droite
    x += xVel;
 
    //Si le point se rapproche trop des limites(gauche ou droite) de l'ecran
    if( ( x < 0 ) || ( x + POINT_WIDTH > SCREEN_WIDTH ) )
    {
        //On revient
        x -= xVel;
    }
 
    //Bouge le point en haut ou en bas
    y += yVel;
 
    //Si le point se rapproche trop des limites(haute ou basse) de l'ecran
    if( ( y < 0 ) || ( y + POINT_HEIGHT > SCREEN_HEIGHT ) )
    {
        //On revient
        y -= yVel;
    }
 
 
 
    offset.x = x;
    offset.y = y;
 
    //On blitte la surface
    SDL_BlitSurface( source, NULL, destination, &offset );
    SDL_Flip(destination);
}

Comme tu peux le voir, la différence avec le code de loka, c'est que j'envoie l'image du point et de l'ecran dans la fonction "handle_input()" , et à la fin de celle-ci je lance directement la fonction show (sans repasser par le main).
Petite autre différence : à la fin de la fonction show je n'apel pas de fonction "apply surface", je blit et flip directement mon ecran.

Bon je pense pas que ces modifications soient la cause du problème puisque le programme marche, je ne peux juste pas bouger le point en restant appuyé sur une touche. :cry:

Merci de ton aide en tout cas.

23/01/2009, 16h31
loka

Bonjour,

Est-il possible de voir ta boucle de jeu principale.

Je te conseille aussi de récupérer les sources disponibles sur le tuto et d'essayer de meiux comprendre comment ça marche avant de tout réécrire, change juste quelques points au début.

Bonjour loka et merci de ta réponse.

J'ai effectivement fais d'abord le tutorial en me servant des sources pour comprendre pas à pas, puis je l'ai refais mais en codant à ma sauce (mais en reprenant tout de même tes fonctions).
Le gros du changement par rapport à ton programme c'est que je sépare le main, des class et des fonctions à l'aide d'un nouveau .cpp et d'un .h

Enfin bref voici le code de mon main :

Code:

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
 int main(int argc, char *argv[])
{
    int continuer =1;
    Point monPoint;
 
    SDL_Event event2;
    SDL_Surface *affichePoint = NULL;
    SDL_Surface *screen = NULL;
 
    SDL_Init(SDL_INIT_EVERYTHING);
    screen = SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_SWSURFACE );
    SDL_WM_SetCaption( "Bouge le point", NULL );
 
    affichePoint = SDL_LoadBMP( "dot.bmp" );
 
 
    while (continuer)
    {
        while( SDL_PollEvent( &event2 ) )
        {
            SDL_FillRect( screen, &screen->clip_rect, SDL_MapRGB( screen->format, 255, 255, 255 ) );
            monPoint.handle_input(event2,affichePoint, screen);
            //On remplit l'ecran de blanc
 
            //On affiche le point sur l'ecran
            //monPoint.show(affichePoint, screen);
            if( event2.type == SDL_QUIT )
            {
                //On quitte the programme
                continuer = 0;
            }
 
        }
 
    }
    //Libèration des surfaces
    SDL_FreeSurface( affichePoint );
    //On quitte SDL
    SDL_Quit();
 
return EXIT_SUCCESS;
}

29/01/2009, 00h45
LittleWhite

Excuse du retard.

Peux tu donner le code complet, je n'arrive pas à voir l'erreur directement... J'ai l'impression que c'est simple ( je me doute de quelque chose )
D'ailleurs je vais expliquer, la marche à suivre pour chercher l'erreur. À priori c'est pas un truc qui se voit au premier coup d'oeil.
Donc avec ton logiciel de développement , tu dois avoir un debuggueur. Je pense que c'est une très bonne occasion de l'utiliser.
( Si tu ne l'as jamais fait , on peut t'aider ;) , mais indique quel IDE tu utilise , et le système d'exploitation , merci )
Il faut que tu place un point d'arrêt ( breakpoints ) , au debut de la méthode show ( sur la première ligne ) et que tu regarde les valeurs ( grace au débuggueur ) de x , y , xVel, yVel.

( Je demandais le code complet , pour tester moi même , mais ce n'est pas très pédagogique )...

Salut et merci de ta réponse.

Alors mon IDE est dev-C++, je suis sous windows, non je n'ai encore jamais touché au debugger je ne sais même pas comment cela marche.

Je vais t'écrire le code complet, et en attendant ta réponse je vais tenter d'en apprendre d'avantage sur le debugger.

Le main.cpp :

Code:

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
 #include <iostream>
#include <string>
#include <SDL\SDL.h>
#include <SDL\SDL_image.h>
#include <SDL\SDL_ttf.h>
#include "point.h"
 
//Les attributs de l'écran (640 * 480)
const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;
const int SCREEN_BPP = 32;
 
//Les dimensions du point (l'image qu'on va deplacer)
const int POINT_WIDTH = 20;
const int POINT_HEIGHT = 20;
 
 
 
int main(int argc, char *argv[])
{
    int continuer =1;
    Point monPoint;
 
    SDL_Event event2;
    SDL_Surface *affichePoint = NULL;
    SDL_Surface *screen = NULL;
 
    SDL_Init(SDL_INIT_EVERYTHING);
    screen = SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_SWSURFACE );
    SDL_WM_SetCaption( "Bouge le point", NULL );
 
    affichePoint = SDL_LoadBMP( "dot.bmp" );
 
 
    while (continuer)
    {
        while( SDL_PollEvent( &event2 ) )
        {
//On remplit l'ecran de blanc
            SDL_FillRect( screen, &screen->clip_rect, SDL_MapRGB( screen->format, 255, 255, 255 ) );
            monPoint.handle_input(event2,affichePoint, screen);
 
 
            if( event2.type == SDL_QUIT )
            {
                //On quitte the programme
                continuer = 0;
            }
 
        }
 
    }
    //Libèration des surfaces
    SDL_FreeSurface( affichePoint );
    //On quitte SDL
    SDL_Quit();
 
return EXIT_SUCCESS;
}

Point.cpp

Code:

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
#include <iostream>
#include <string>
#include <SDL\SDL.h>
#include <SDL\SDL_image.h>
#include <SDL\SDL_ttf.h>
#include "point.h"
 
//Les attributs de l'écran (640 * 480)
const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;
const int SCREEN_BPP = 32;
 
//Les dimensions du point (l'image qu'on va deplacer)
const int POINT_WIDTH = 20;
const int POINT_HEIGHT = 20;
 
 
 
Point::Point()
{
    //Initialisation des coordonnees
    x = 0;
    y = 0;
 
    //Initialisation de la vitesse
    xVel = 0;
    yVel = 0;
}
 
 
 
void Point::handle_input(SDL_Event event, SDL_Surface* affichePoint,SDL_Surface* screen)
{
 
 
    if( event.type == SDL_KEYDOWN )
    {
        //ajustement de la vitesse
        switch( event.key.keysym.sym )
        {
            case SDLK_UP: yVel -= POINT_HEIGHT / 2; break;
            case SDLK_DOWN: yVel += POINT_HEIGHT / 2; break;
            case SDLK_LEFT: xVel -= POINT_WIDTH / 2; break;
            case SDLK_RIGHT: xVel += POINT_WIDTH / 2; break;
            default: break;
        }
    }
    //Si une touche a ete relachee
    else if( event.type == SDL_KEYUP )
    {
        //ajustement de la vitesse
        switch( event.key.keysym.sym )
        {
            case SDLK_UP: yVel += POINT_HEIGHT / 2; break;
            case SDLK_DOWN: yVel -= POINT_HEIGHT / 2; break;
            case SDLK_LEFT: xVel += POINT_WIDTH / 2; break;
            case SDLK_RIGHT: xVel -= POINT_WIDTH / 2; break;
            default: break;
        }
    }
    show(affichePoint, screen);
}
 
 
 
void Point::show(SDL_Surface* source, SDL_Surface* destination)
{
    SDL_Rect offset;
    //Bouge le point à gauche ou à droite
    x += xVel;
 
    //Si le point se rapproche trop des limites(gauche ou droite) de l'ecran
    if( ( x < 0 ) || ( x + POINT_WIDTH > SCREEN_WIDTH ) )
    {
        //On revient
        x -= xVel;
    }
 
    //Bouge le point en haut ou en bas
    y += yVel;
 
    //Si le point se rapproche trop des limites(haute ou basse) de l'ecran
    if( ( y < 0 ) || ( y + POINT_HEIGHT > SCREEN_HEIGHT ) )
    {
        //On revient
        y -= yVel;
    }
 
 
 
    offset.x = x;
    offset.y = y;
 
    //On blitte la surface
    SDL_BlitSurface( source, NULL, destination, &offset );
    SDL_Flip(destination);
}
 
 
/*void apply_surface( int x, int y, SDL_Surface* source, SDL_Surface* destination)
{
    SDL_Rect offset;
 
    offset.x = x;
    offset.y = y;
 
    //On blitte la surface
    SDL_BlitSurface( source, NULL, destination, &offset );
    
}*/

Point.h

Code:

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
 
#ifndef DEF_POINT
#define DEF_POINT
 
//void apply_surface( int x, int y, SDL_Surface* source, SDL_Surface* destination);
 
 
class Point
{
    private:
    //Les coordonnées x et y du point
    int x, y;
 
    //La vitesse du point
    int xVel, yVel;
 
    public:
    //Initialisation des variables
    Point();
 
    //Recupere la touche pressee et ajuste la vitesse du point
    void handle_input(SDL_Event event,SDL_Surface* affichePoint,SDL_Surface* screen);
 
    //Montre le point sur l'ecran
    void show(SDL_Surface* source, SDL_Surface* destination);
};
 
#endif

Comme tu peux le vois je n'ai pour le môment rien implanté au niveau des timers, je pensais le faire après en fait, mais déja la j'avais des soucis anormaux ...

j'ai d'ailleurs tenter d'enlever tout ce qui était relatif aux timers dans les sources de loka, mais je n'ai pas rencontré le même problème que moi, j'en ai déduit que ce n'était pas ça la cause de mon problème.

Voilà en esperant que tu pourra m'aider ...
Merci de ton aide.

Salut,

On s'approche de la solution.
Je viens de compiler le programme et je vais te donner de conseils :
Quand tu fais un include d'un fichier fais attention au minuscule et au majuscule. Par exemple dans le code que tu as donné tu inclus point.h , mais, dans le post tu l'appelle Point.h
( En fait, c'est juste que comme j'ai mis une majuscule , mon compilateur ne reconnaissait pas le fichier ) ( Et aussi parce que mon système est pointilleux sur les noms )

Le deuxième conseil est dans le même genre, quand tu inclut des fichiers qui sont dans des dossiers ( ceux de la SDL par exemple ), met '/' et non '\' , comme ça sur les systèmes linux ça marchera aussi. ( Enfin ok, il se peut que cela ne soit pas important pour toi ).

Bref , le problême est que la fonction handle_input n'est appelée que lorsque il y a un événement. Ce qui veut dire, que lorsque la souris bouge , ou un boutton d'appuyer ( ou de relacher ) , ou une touche.

Normalement cette fonction devrait toujours être appelée même s'il n'y a pas d'événement.
J'ai trouvé.
Je te conseille de garder une doc de la sdl sous la min ( il y en a un peu partout sur le net ).
Donc , ma méthode de débugguage n'est pas conseillé , mais en executant le programme je connaissais déjà beaucoup la cause du problème. ( experiences ).
J'ai débugguer en affichant du texte sur la ligne de commande ( fenêtre dos ), pour savoir ce que executer le programme et quand. ( Bref pas la meilleure méthode, mais peux être rapide ).
Donc j'ai remarqué que la fonction handle input n'était appelée que lorsqu'il y a un événement.
Pourquoi ?
Je regarde dans le main , réfléchi , lit la doc de la fonction SDL_PollEvent ( qui récupère nos événements ) et remarque que lorsqu'il n'y a pas d'évenement , renvoie NULL.
Inseré dans un while comme le fait Loka , le contenu du while ne va pas être executé.
Ce qui veut donc dire que handle_input n'est pas appeler.
Comme tu as placé l'appel à la fonction show ( qui gère aussi le déplacement de l'image ) dans handle_input , la position n'est pas modifié ( de l'image ).
Donc je propose comme correction propre ceci :
( code du main )
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 while (continuer) { while( SDL_PollEvent( &event2 ) ) { monPoint.handle_input(event2,affichePoint, screen); if( event2.type == SDL_QUIT ) { //On quitte the programme continuer = 0; } } //On remplit l'ecran de blanc SDL_FillRect( screen, &screen->clip_rect, SDL_MapRGB( screen->format, 255, 255, 255 ) ); monPoint.show(affichePoint,screen); }
Petite autre chose à faire , enlever l'appel de show qui est dans la fonction handle_input.
Comme tu peux le remarquer, je fais le show dans la grande boucle while, mais pas dans celle des événements.
Je fais aussi l'éffacement de l'écran, afin qu'il soit effacé lorsque l'on va afficher.

Si tu as un quelque problème de compréhension , n'hésite pas à faire signe ... surtout qu'il se peut que je ne sois pas très clair.

Pour le cours de débugguage, je pense que c'est trouveable sur le net , et même sur ce site. Moi même n'ayant jamais trop utilisé le debuggueur de Dev cpp , je ne pourrais pas t'aider précisément.

Voilà \o/

30/01/2009, 13h29
Nothingness0x

Salut LittleWhite,

Avant toutes choses, merci de ton aide car ça marche ... je sais pas trop quoi dire j'ai presque honte telement le problème était tout con finalement , j'aurais franchement pu le trouver tout seul. :(

En tout cas j'ai bien compris ta correction.

Maintenant mon point bouge super vite, donc j'imagine qu'il faut que je m'attaque au timer pour réguler tout cela.

Donc merci encore, et on tu aura peut être l'occasion de me recroiser sur un autre topic si je bloque sur autre chose. :mrgreen:

A +