Problème animation sprite

**Edouard Kaiser** · 23/11/2005, 15h26

Bonjour à tous !
En ce moment je suis en pleine programmation multimedia et plus particulierement l'affichage de sprite.
Que ce soit Allegro ou SDL, j'ai remarque que les fonctions de "blit" prennent à chaque fois le coin superieur gauche pour l'affichage d'une image.

De ce fait, il est apparu un problème, en effet :
- un sprite est composé de plusieurs images qui enchainées les une à la suite des autres forment une animation.
- si une image d'un sprite est legerement plus grande que la precedente (car le personnage s'étire par exemple !), et bien à cause de l'affichage qui prend toujours le coin superieur droit, l'image ne prendra pas de hauteur en Y mais on aura " l'impréssion" que le personnage s'enfonce dans le decord au lieu de s'étirer en hauteur.

Je ne sais pas si je me suis bien fais comprendre, mais j'ai l'animation de "Ryu". Lorsqu'il ne bouge pas, il se comptente de se lever sur la pointe des pieds et redescend (ceux qui ont joué à Street Fighter le sauront...), bah la au lieu qu'il s'eleve un peu et redescend, bah j'ai un Ryu qui ne s'eleve pas, par contre les pieds bouge bizarrement (s'enfoncent quoi...)

J'espère que quelqun a déja rencontré ces cas de figures et saura m'indiquer les bonnes méthodes d'animation de sprite

Merci !

**Laurent Gomila** · 23/11/2005, 17h04

Suffit de décaler l'origine du blit (selon la taille du sprite), pour faire en sorte que ce soit le centre-bas qui soit fixe, et non le coin haut-gauche.

Tu peux aussi éditer le titre de ton message, parce qu'il n'a rien à voir avec ton problème

**Edouard Kaiser** · 23/11/2005, 20h35

En gros remonter les sprites plus grand d'une valeur egale a la difference de taille entre l'image precedente ?

**Edouard Kaiser** · 24/11/2005, 21h44

J'ai essayé de faire quelque chose dans le genre a chaque tour de boucle d'affichage :

Code :

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

1
2
3
 
int difference = (SPRITE[compteur]->hauteur) - (SPRITE[compteur-1]->hauteur);
position_y -= difference;

On s'approche dangereusement d'une animation plausible, mais il reste encore une "impression" de leger enfoncement, quelque chose a du m'échapé.
Je manque cruellement de théorie sur l'animation 2D. Si quelqun a de la doc, je suis preneur

Merci.

**Laurent Gomila** · 25/11/2005, 09h45

Moi je ferais plutôt ça :

Code :

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

1
2
3
const int position_y_voulue = 200; // par exemple
 
position_y = position_y_voulue - SPRITE[compteur]->hauteur;

**Edouard Kaiser** · 25/11/2005, 13h05

je t'avoue que j'ai du mal à saisir en quoi ce système peut m'éviter d'avoir cet effet d'"enfoncement".

Tu soustrait à une position constante la hauteur du sprite que l'on veut afficher

:

J'ai fais un petit schema de comment ça se présente en mettant une animation à 3 images et comment elles devraient s'enchainer normallement :

En fait c est la base qui doit toujours etre horizontalement aligné.

**Laurent Gomila** · 25/11/2005, 13h35

Ben oui, comme ça au lieu que le haut soit fixe, c'est le bas qui l'est (enfin ça dépend où on place haut et bas).

Dans ton schéma "idéal", le bas (qui est donc la position fixe) est position_y_voulue, auquel on retranche la hauteur du sprite courant, et hop on obtient bien la position à laquelle coller le sprite pour que son bas tombe toujours sur position_y_voulue.

C'est extrêmement simple, suffit d'y réflechir une seconde.

**keil** · 25/11/2005, 13h40

et ca aurait pas été plus simple d'avoir une planche de sprite uniforme?
je veux dire, chaque frame ayant la meme taille?

ça t'éviterait d'avoir à faire des test comme ca

**Edouard Kaiser** · 25/11/2005, 14h01

C'est bon j'ai saisi, (pfiou désolés de pas avoir vu plus tot c etait évident...).
Sinon pour la palette d'images ayant la meme taille oui j'y ai pensé, c'est une solution, mais j'avoue avoir eu la flemme de retoucher tous les sprites.

**Edouard Kaiser** · 25/11/2005, 17h51

ça fonctionne du feu de Dieu, merci

**Edouard Kaiser** · 26/11/2005, 00h50

Plus généralement est ce que vous sauriez quel est le secret d'une animation fluide et plausible ?
J'essaye d'animer le personnage qui avance mais ce n'est pas du tout crédible, soit il avance trop vite, soit trop lentement. Bref il doit y avoir une manière bien spéciale d'incrémenter x et plus généralement de déplacer le sprite d'un personnage sur x.

Je vous montre mon code on sait jamais si ça interesse quelqun :

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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
 
#include <allegro.h>
#include <stdio.h>
#include <time.h>
 
#define NB_SPRITES_STAND 13
#define NB_SPRITES_WALK  6
#define NB_SPRITES_BACK  6
 
int main(void)
{
    BITMAP* DESSIN_STAND[NB_SPRITES_STAND];
    BITMAP* DESSIN_WALK[NB_SPRITES_WALK];
    BITMAP* DESSIN_BACK[NB_SPRITES_BACK];
 
    BITMAP* page;
    BITMAP* background;
 
    PALETTE pal;
    int i,posx,posy,dessin_cmpt,walk_cmpt,back_cmpt,tmp_time;
    char buf[80]; /* Stocker le nom des fichiers */
 
    /* Initialisation du format d'affichage du texte */
    set_uformat(U_ASCII);
 
    /* Initialisation d'Allegro */
    allegro_init();
 
    /* Initialisation des E/S clavier */
    if(install_keyboard() != 0)
    {
        allegro_message(allegro_error);
        allegro_exit();
        return 1;
    }
 
    set_color_depth(32);
 
    /* Initialisation du mode graphique */
    if(set_gfx_mode(GFX_AUTODETECT_WINDOWED,640,480,0,0) != 0)
    {
        allegro_message(allegro_error);
        allegro_exit();
        return 1;
    }
 
    /* Chargement de toutes les images faisant le decort */
    background = load_bitmap("data//background//back_static.bmp",NULL);
 
    if(!background)
    {
        allegro_message("Error load bitmap !");
        allegro_exit();
        return 1;
    }
 
    /* Notre buffer */
    page = create_bitmap(640,480);
 
    /* Chargement en memoire des sprites */
 
    /* Ryu qui ne bouge pas */
    for(i=0; i<NB_SPRITES_STAND;i++)
    {
        sprintf(buf,"data\\characters\\ryu\\ryu_stand\\ryu%d.pcx",i);
 
        DESSIN_STAND[i] = load_bitmap(buf,pal);
 
        if(!DESSIN_STAND[i])
        {
			allegro_message(allegro_error);
            allegro_exit();
            return 1;
        }
	}
 
    /* Ryu qui avance */
    for(i=0;i<NB_SPRITES_WALK;i++)
    {
        sprintf(buf,"data\\characters\\ryu\\ryu_walk\\ryu%d.pcx",i);
 
        DESSIN_WALK[i] = load_bitmap(buf,pal);
 
        if(!DESSIN_WALK[i])
        {
			allegro_message(allegro_error);
            allegro_exit();
            return 1;
        }
	}
 
    /* Ryu qui recule */
    for(i=0;i<NB_SPRITES_BACK;i++)
    {
        sprintf(buf,"data\\characters\\ryu\\ryu_back\\ryu%d.pcx",i);
 
        DESSIN_BACK[i] = load_bitmap(buf,pal);
 
        if(!DESSIN_BACK[i])
        {
			allegro_message(allegro_error);
            allegro_exit();
            return 1;
        }
	}
 
    set_palette(pal);
 
    /* Position initialise du sprite */
    posx = 200;
   	posy = 213;
    dessin_cmpt = 0;
    walk_cmpt = 0;
    back_cmpt = 0;
    tmp_time = 0;
 
    const int position_y_voulue = 398; // par exemple
 
    /* Boucle principale d'affichage */
    do
    {
        /* Decort statique */
        stretch_sprite(page,background,0,0,640,480);
 
        /* Gestion du clavier */
        if(key[KEY_RIGHT])
        {
            posx+=2;
 
            /* On passe au sprite suivant */
            if(tmp_time++ == 12)
            {
                tmp_time = 0;
 
                ++walk_cmpt;
 
                if(walk_cmpt == NB_SPRITES_WALK)
                    walk_cmpt = 0;
 
                posy = position_y_voulue - (DESSIN_WALK[walk_cmpt]->h*2);
            } 
 
            /* Affichage des joueurs */
            stretch_sprite(page,DESSIN_WALK[walk_cmpt],posx,posy, DESSIN_WALK[walk_cmpt]->w*2,DESSIN_WALK[walk_cmpt]->h*2);        
        }
        else if(key[KEY_LEFT])
        {
            posx--;
 
            /* On passe au sprite suivant */
            if(tmp_time++ == 12)
            {
                tmp_time = 0;
 
                ++back_cmpt;
 
                if(back_cmpt == NB_SPRITES_BACK)
                    back_cmpt = 0;
 
                posy = position_y_voulue - (DESSIN_BACK[back_cmpt]->h*2);
            } 
 
            /* Affichage des joueurs */
            stretch_sprite(page,DESSIN_BACK[back_cmpt],posx,posy, DESSIN_BACK[back_cmpt]->w*2,DESSIN_BACK[back_cmpt]->h*2);
        }
        else
        {    
            /* On passe au sprite suivant si le temps est ecoule */
            if(tmp_time++ == 12)
            {
                tmp_time = 0;
 
                ++dessin_cmpt;
 
                if(dessin_cmpt == NB_SPRITES_STAND)
                    dessin_cmpt = 0;
 
                posy = position_y_voulue - (DESSIN_STAND[dessin_cmpt]->h*2);
            }
 
            /* Affichage du joueur */
            stretch_sprite(page,DESSIN_STAND[dessin_cmpt],posx,posy, DESSIN_STAND[dessin_cmpt]->w*2,DESSIN_STAND[dessin_cmpt]->h*2);
        }
 
        /* C'est bon on peut tout afficher à l'ecran */
        blit(page,screen,0,0,0,0,640,480);
 
    }
    while(!key[KEY_ESC]);
 
    /* Liberation de la memoire */
    destroy_bitmap(page);
    destroy_bitmap(background);
 
    for(i = 0; i<NB_SPRITES_STAND; i++)
	   	destroy_bitmap(DESSIN_STAND[i]);
 
    for(i = 0; i<NB_SPRITES_WALK; i++)
	   	destroy_bitmap(DESSIN_WALK[i]);
 
    for(i = 0; i<NB_SPRITES_BACK; i++)
	   	destroy_bitmap(DESSIN_BACK[i]);
 
    exit(EXIT_SUCCESS);
 
} END_OF_MAIN();

**Laurent Gomila** · 26/11/2005, 10h55

A ma connaissance, y a rien de magique. Faut faire des tests pour trouver la vitesse adéquate pour chaque animation.

**keil** · 28/11/2005, 11h45

flemme de lire ton code!
pour une anim fluide, il faut jouer sur les fps,

**bafman** · 28/11/2005, 12h50

ce n'est pas le probleme ici... le probleme c'est de reussir a faire avancer le sprite en fonction de l'animation affichée, pas d'afficher ca fluidement en fonction du temps...