Discussion :

[sarkande]

Bonjour,

j'ai un problème avec mon programme, je suis en train de développer un jeu et je m'occupe de la partie animation de sprite.

Quand je charge ma fonction pour animer mon personnage, si j'appuie sur une touche les animations ne se déroulent pas comme prévus (saccade, ou alors le personnage avance mais reste dans la même animation)

néanmoins si j'appuie sur une deuxième touche en même temps, les animations se déroulent normalement (ex: touche droite puis touche bas).

Quelqu'un aurait -il une idée ?

le fichier animation.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
 
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <sdl/sdl.h>
#include <SDL/SDL_image.h>
 
#include "animation.h"
#include "constante.h"
 
void mouvementSprite( Sprite *sprite, int direction )
{
    // On affecte la direction au sprite
    sprite->direction = direction;
 
    // on affecte l'animation correcpondant à la direction au sprite
    if (direction != AUCUNE_DIRECTION)
    {
        sprite->anim = 1;
        switch (direction)
        {
 
        case DIRECTION_DROITE:
            sprite->orientation = DROITE; //le sprite s'oriente vers la droite
            break;
 
        case DIRECTION_GAUCHE:
            sprite->orientation = GAUCHE; //le sprite s'oriente vers la gauche
            break;
 
        default:
            ;
        }
    }
    else
        // si le sprite est arreté, on ne l'anime pas
        sprite->anim = 0;
 
    // on met la première animation
    sprite->anim_courante = 0;
    sprite->temps_anim_courante = 0;
 
    // on regle la source de l'image à copier
    sprite->source.y = sprite->orientation * sprite->hauteur;
    sprite->source.x = sprite->anim_courante * sprite->largeur;
}
 
 
int chargementSprite( Sprite *sprite, const char *image )
{
    sprite->image = IMG_Load( image ); //on charge l'image dans la composante image du sprite
    if ( sprite->image == NULL )
    {
        fprintf(stderr, "Echec de chargement du fichier %s : %s.\n", image, SDL_GetError());
        return 0;
    }
    /* Verification du format de l'image */
    if ( (sprite->image->w != 540) || (sprite->image->h != 120) )
        if ( sprite->image == NULL )
        {
            fprintf(stderr, "L'image du fichier %s doit être de taille 540*120 pixels.\n", image);
            SDL_FreeSurface(sprite->image);
            return 0;
        }
    if ( !sprite->image )
        return 0;
 
    // on fixe la cle de transparance
    SDL_SetColorKey( sprite->image, SDL_SRCCOLORKEY, SDL_MapRGB( sprite->image->format, 250, 65, 245) );
 
    /* On definit d'abord les propriétés du sprite : */
    // le sprite n'est pas animé par defaut
    sprite->anim = 0;
 
    // on commence par la première animation
    sprite->anim_courante = 0;
 
    // le sprite dispose de neuf animations
    sprite->total_anims = 9;
 
    // par défaut, le sprite est tourné vers le bas
    sprite->orientation = DROITE;
 
    // chaque animation dure 20 affichages
    sprite->temps_anim = 20;
 
    // Le temps qu'il reste à afficher l'animation courante
    sprite->temps_anim_courante = 0;
 
    // On definit ensuite les dimentions du sprite.
    sprite->largeur = 60;
    sprite->hauteur = 60;
 
    sprite->source.x = sprite->anim_courante * sprite->largeur;
    sprite->source.y = sprite->orientation * sprite->hauteur;
    sprite->source.w = sprite->largeur;
    sprite->source.h = sprite->hauteur;
 
    sprite->dest.x = 0;
    sprite->dest.y = 0;
    sprite->dest.w = sprite->largeur;
    sprite->dest.h = sprite->hauteur;
 
    // on definit enfin la vitesse et la direction du sprite
    sprite->vitesse = 3;
    sprite->direction = AUCUNE_DIRECTION;
 
    return 1;
}
 
 
void affichageSprite( Sprite *sprite, SDL_Surface *destination )
{
 
 
    // le sprite vas vers le haut
    if (sprite->direction & DIRECTION_GAUCHE)
    {
        // on va à gauche et on fait attention a ne pas sortir de l'ecran
        sprite->dest.x -= sprite->vitesse;
        if (sprite->dest.x < 0)
            sprite->dest.x = 0;
    }
    else if (sprite->direction & DIRECTION_DROITE)
    {
        // on va à droite et on fait attention a ne pas sortir de l'ecran
        sprite->dest.x += sprite->vitesse;
        if (sprite->dest.x + sprite->largeur > LONGUEUR_FENETRE)
            sprite->dest.x = LONGUEUR_FENETRE - sprite->largeur;
    }
 
 
    /* si le sprite est animé, on gere l'animation */
    if (sprite->anim)
    {
        // on decremente le temps restant à l'animation courante
        sprite->temps_anim_courante-=5;
        // et on regarde s'il est temps de changer d'animation
        if ( sprite->temps_anim_courante <= 0 )
        {
            // s'il faut changer, on passe à l'animation suivante
            sprite->anim_courante++;
            // si on était à la dernière animation, on repasse à la première
            if (sprite->anim_courante >= sprite->total_anims)
                sprite->anim_courante = 0;
 
            // on regle la source à copier
            sprite->source.x = sprite->largeur * sprite->anim_courante;
            sprite->temps_anim_courante = sprite->temps_anim;
        }
    }
 
    // enfin, on dessine le sprite à l'ecran
    SDL_BlitSurface( sprite->image, &sprite->source, destination, &sprite->dest );
}<br><br>

Le fichier jeu.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
 
#include <string>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <SDL/SDL.h>
#include <SDL/SDL_ttf.h>
#include <SDL/SDL_mixer.h>
#include <SDL/SDL_image.h>
 
 
#include "animation.h"
#include "constante.h"
 
using namespace std;
int jouer(SDL_Surface *ecran,string refClasse,string refPseudo,int refIntelligence,int refForce,int refAdresse,int refConstitution)
{
    //variables
    int jeu=1;
    Uint32 temps_courant, prochain_rendu = 0;
    char chargementImagePerso[100] = "image/jeu/ninja.bmp";
 
    Sprite perso; //variable de notre personnage
    SDL_Event evenement;
    SDL_Surface *fond=NULL;
    SDL_Rect positionFond;
 
    positionFond.x=0;
    positionFond.y=0;
    fond = IMG_Load("image/jeu/level_test.bmp");
 
    //initialisation du charset
    if ( !chargementSprite( &perso, chargementImagePerso ) )
    {
        SDL_Quit();
        return EXIT_FAILURE;
    }
 
    //position de depart du perso
    perso.dest.x = 0;
    perso.dest.y = 237;
    //direction de depart
    mouvementSprite( &perso, DIRECTION_DROITE );
    mouvementSprite( &perso, AUCUNE_DIRECTION );
 
 
    do
    {
 
        while(SDL_PollEvent(&evenement))
        {
            switch(evenement.type)
            {
            case SDL_QUIT :
                return EXIT_SUCCESS; //pour quitter le pgm
                break;
            case SDL_KEYDOWN :
                switch(evenement.key.keysym.sym)
                {
                case SDLK_ESCAPE: //pour quitter le pgm
                    jeu = 0;
                    break;
                case SDLK_RIGHT:  //le perso va vers la droite
                    mouvementSprite( &perso, DIRECTION_DROITE );
                    break;
                case SDLK_LEFT:   //le perso va vers la gauche
                    mouvementSprite( &perso, DIRECTION_GAUCHE );
                    break;
                default:
                    (void) NULL;
                    break;
                }
                break;
            case SDL_KEYUP :
                switch(evenement.key.keysym.sym)
                {
                case SDLK_ESCAPE:
                    jeu = 0;   //pour quitter le pgm
                    break;
                case SDLK_RIGHT:   //le perso va vers la droite
                    if (perso.direction == DIRECTION_DROITE)
                        mouvementSprite( &perso, AUCUNE_DIRECTION );
                    break;
                case SDLK_LEFT:   //le perso va vers la gauche
                    if (perso.direction == DIRECTION_GAUCHE)
                        mouvementSprite(&perso, AUCUNE_DIRECTION);
                    break;
                default:
                    (void) NULL;
                    break;
                }
                break;
            default:
                (void) NULL;
                break;
            }
        }
 
        //le pgm compte le nombre de milliseconde écoulé depuis le lancement
        temps_courant = SDL_GetTicks();
        if (temps_courant > prochain_rendu)
        {
            prochain_rendu = temps_courant + 20;
 
            SDL_BlitSurface(fond, NULL, ecran , &positionFond);
 
            affichageSprite( &perso, ecran ); //et on blit le personnage
 
            SDL_Flip(ecran); //mise a jour de l'ecran
        }
    }
    while (jeu);
 
 
    /* liberation des surfaces */
    SDL_FreeSurface(ecran);
    SDL_FreeSurface(perso.image);
 
    return EXIT_SUCCESS;
 
}<br><br>

merci de me repondre au plus vite

[skeud]

Le fait que ça sacade viens du fait que tes frame ne sont pas "fréquencée" . Dans ta boucle principale, il faut que tu rajoute un sleep .

Imaginons que tu veuilles du 24 FPS.
Chque frame possèdera donc 42ms pour s'afficher. Donc tu mets un compteur en debut de boucle, un en fin de boucle, et si la différence est > 0 alors tu sleep le temps qu'il reste. De cette manière le jeu sera plus fluide .

concernant le problème de touche, je vois pas trop mais je pencherais pour tes masque binaire, je sais pas pourquoi mais je le sens pas cette manière de faire: plutot préférer un == qu'un & .