Allegro - Problème de programmation

Bonjour, à tous.
Donc voila, tout est dans le titre, j'ai un projet à faire à l'université : un casse brique sous Allegro ( Je compile sous code::blocks) (je ne suis pas très bon en programmation en plus ...) Et j'ai un petit problème: je n'arrive pas à faire bouger la balle et la palette en même temps, donc je voulais savoir si quelqu'un savait si, dans cette bibliothèque, il y a un moyen pour résoudre mon problème...
Merci d'avance pour les aides...

Salut mec!
Alors j'aurais surement moyen de t'aider, je suis actuellement en 2eme année d'un DUT GEI et l'année dernière mon projet était de reproduire le jeu tétris en C avec Allegro et sous code blocks ^^

Donc si tu veux que je t'aide soit un petit peu plus précis et à la limite passe ton code ça sera plus simple ;)

A+

Citation:

je n'arrive pas à faire bouger la balle et la palette en même temps

C'est parce que tu utilises des fonctions bloquantes...
(*Et c'est pas bien ?* => non pas du tout).
Comme dit plus haut poste ce que tu as déjà commencé à programmer on t'aidera à partir de là.

Pour compléter les deux derniers posts, l'usage de fonctions bloquantes dans ce cas de figure particulier révèle souvent une erreur de conception de ton application entière, ce qui est normal quand on débute.

En fait, il faut faire une boucle qui synchronise le jeu entier (en général, au début de chaque VBL) par périodes fixes, et au début de laquelle tu fais tous les contrôles dont tu as besoin : test du clavier, déplacement de la balle d'une distance donnée, et déplacement de la raquette sur une certaine distance elle-aussi. Ensuite, le reste : contrôle des collisions, gestion des scores, etc. Puis, là, tu attends la fin du temps imparti, tu boucles, et tu recommences.

Merci de tout vos posts :)
Donc en fait, il faut que j'utilise un timer ?
bon voila ce que j'ai fait ...

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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
#include <allegro.h>
#define ECRAN_X	500
#define ECRAN_Y	500
 
// le nombre total de balles
#define NB_BALLE	1
 
 
// Une énumération plutôt que trois #define (rectangle vaut 0 et cercle 1)
enum{balle, rectangle};
 
// structure qui rassemble tous les attributs d'une forme et définition
//(typedef) d'un type "FORME" équivalent à cette structure
typedef struct BALLE
{
	int type;			//rectang,triang,cercle
	int x,y;			//position
	int tx,ty;			//taille
	int dx,dy;		//deplacement
	int couleur;
 
}BALLE;
 
// déclarations des 3 fonctions du programme
void initialisation_balle	(BALLE*f);
void mouvement_balle	(BALLE*f);
void assemble_balle		(BALLE*f, BITMAP* bmp);
/*
Fonction d'initialisation de la balle
faire tant que la touche de deplacement du clavier = 0
*/
void initialisation_balle(BALLE*f)
{
	f->x = ECRAN_X/2;
	f->y = 9*(ECRAN_Y)/10;
	f->tx = 10;
	f->ty = 10;
	f->dx = 3;
	f->dy = 3;
	f->couleur=makecol(255,255,255);
}
/*
Modifier les coordonnées d'une forme en fonction de ses valeurs de déplacement (dx et dy)
Contrôler les bords (rebond en cas de collision du bord)
*/
void mouvement_balle(BALLE*f)
{
   	f->x += f->dx;
   	f->y -= f->dy;
   	// si la position en x ou y sort de l'écran et que la pas d'avancement ne ramène pas vers la
   	// zone écran, alors inverser le pas d'avancement
   	if (  (f->x >= ECRAN_X - (f->tx) || (f->x <= (f->tx) ))) /   	
             {
        f->dx = -f->dx;
   	}
   	if (  (f->y <= 10  ) || (f->y >= ECRAN_Y - f->ty) )
   	{
        f->dy = -f->dy;
   	}
}
/*
Afficher une forme dans une bitmap mémoire en fonction de son type (rectangle ou cercle)
*/
void assemble_balle(BALLE*f, BITMAP* bmp)
{
   	switch(f->type)
   	{
        case balle :
        circlefill( bmp, f->x, f->y, f->ty, f->couleur);
        break;
	}
}
 
int main(void)
{
    int i;
// un tableau de pointeurs de FORMES
BALLE* TAB[NB_BALLE];
 
//  bitmaps buffer
BITMAP*page;
 
   	allegro_init();
   	install_keyboard();
   	set_gfx_mode(GFX_AUTODETECT, ECRAN_X, ECRAN_Y, 0, 0);
 
   	// créer une bitmap mémoire, le buffer
   	page = create_bitmap(ECRAN_X, ECRAN_Y);
 
 
	// Malloc des poiteurs FORME* du tableau TAB et initialisation de chaque FORME via la
	// fonction d'initialisation
   	for ( i = 0; i <NB_BALLE; i++)
   	{
      		TAB[i] = (BALLE*)malloc(sizeof(BALLE));
      		initialisation_balle(TAB[i]);
   	}
 
	// boucle d'événements, test d'arrêt = presser echapp
   	do
   	{
      		// 1 effacement du buffer
      		clear(page);
 
		// 2 modification des positions de chaque forme et affichage de chaque forme dans le
		// buffer
 
      		for ( i = 0; i <NB_BALLE; i++){
                mouvement_balle(TAB[i]);
	     		assemble_balle(TAB[i], page);
      		}
 
		// 3 affichage du buffer à l'écran
      		blit(page,screen,0,0,0,0,page->w,page->h);
 
        rest(10);
   	}
   	while( !key[KEY_ESC] );
 
   	// sortie boucle évent, nettoyage mémoire allouée
   	destroy_bitmap(page);
   	for (i=0; i< NB_BALLE; i++)
   	{
        free(TAB[i]);
   	}
 
  	return 0;
}
//END_OF_MAIN();

Bon j'avoue c'est un peu désordonné et un peu en mode bourrin... :aie:
J'ai effacé la partie du programme où j'initialisais la raquette parce que ca marchait pas et c'était pas comme cela qu'il fallait faire je pense ^^

Vous pouvez donner vos avis sur ce prog! Et me dire si c'est comme ca qu'il faut que je fasse ou pas...

Je vous poste aussi comment j'étais parti au départ...
(comme vous pouvez le voir, je suis tellement con que j'ai fait un prog qui génère une balle et l'autre qui génère la raquette mais je sais même pas comment faire pour faire les deux choses en même temps...)

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
#include <allegro.h>
#include <math.h>
 
int main(void)
{
   /* BITMAP *bmp;*/
    const int x1=150;
    const int y1=50;
    const int x2=490;
    const int y2=200;
    int y3=440;
    int y4=455;
    int c1=320;
   /* int c2=430;*/
    const int L=640;
    const int H=480;
    int i,j,noir,blanc,rouge,degrade,e,f,raquette,x,x3,x4,I,J,ab,or;
    /*float r;*/
    e=150;
    f=50;
 
    allegro_init();
    install_keyboard();
    /*jpgalleg_init();*/
    set_color_depth(32);
    set_gfx_mode(GFX_AUTODETECT_WINDOWED,L,H,0,0);
 
    blanc=makecol(255,255,255);
    noir=makecol(0,0,0);
    rouge=makecol(255,0,0);
    clear_to_color(screen,blanc);
   /* bmp = load_jpg("jpgalleg.jpg", NULL);*/
    for(I=150;I<470;I++)//degrade de couleur dans le cadre
    {
        for(J=50;J<180;J++)
        {
            degrade=makecol(or,ab,0);
            rectfill(screen,I,J,I+20,J+20,degrade);// établissement de la zone a atteindre
            ab=(255*I)/320;
            or=(255*J)/240;
            ab=ab+138;
            or=or+205;
        }
    }
 
    for(i=0;i<10;i++)//lignes horizontales
    {
        line(screen,e,y1,e,y2,blanc);
        e=e+34;
    }
    for(j=0;j<5;j++)//lignes verticales, avec celle d'avant, ça forme des carrés
    {
 
        line(screen,x1,f,x2,f,blanc);
        f=f+30;
    }
    raquette=140;  // taille de la raquette
    x=raquette;
    x3=c1-(x/2);
    x4=c1+(x/2);
    rectfill(screen,x3,y3,x4,y4,noir);  // positionnement de la raquette
 
while(!key[KEY_ENTER])
{
if(key[KEY_LEFT])//faire translater la raquette a gauche
{
    if(x3>0)
    {
    rectfill(screen,x3,y3,x4,y4,noir);
    rest(10);
    rectfill(screen,x3,y3,x4,y4,blanc);
    x3--;
    x4--;
    }
 
}
if(key[KEY_RIGHT])//faire translater la raquette a droite
{
    if(x4<L)
    {
    rectfill(screen,x3,y3,x4,y4,noir);
    rest(10);
    rectfill(screen,x3,y3,x4,y4,blanc);
    x3++;
    x4++;
    }
 
}//a enlever pr bouger rakette + balle simultanément
 
rectfill(screen,x3,y3,x4,y4,noir);
 
/*blit(bmp, screen, 0, 0, 0, 0, bmp->w, bmp->h);
 
destroy_bitmap(bmp);
*/
}
readkey();
return 0;
}
//END_OF_MAIN()