Gestion des collisions verticales

Version imprimable

Bonjour,

Je suis débutant en c et pour m'entrainner je suis en train de faire un tetris.

J'essaie depuis hier de créer une fonction qui gérera les collisions verticales mais ça ne semble pas vouloir fonctionner même si tout semble être bon (enfin d'après moi).

Voici mon code:
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 // Fonction qui vérifie si il y a collision entre un bloc qui se trouve dans la forme et un bloc se trouvant dans la carte int verifierCollisionCarte(SDL_Rect positionForme, int carte[][TAILLE_FORME], int carteForme[][NB_BLOCS_HAUTEUR]) { SDL_Rect positionBlocCarte; // La position du bloc dans la CARTE int i = 0, j = 0, flag = 0; for(i = 0; i < TAILLE_FORME ; i++) { for(j = 0; j < TAILLE_FORME ; j++) { if(carteForme[i][j]) // Quand on trouve un bloc dans la forme on effectue la vérification { // On convertie la position du bloc de sa position dans la carte de la forme à sa position dans la carte générale // Un bloc se trouvant aux coordonées{1,1} d'une forme se trouvant à {2,2} aurat pour coodonées dans la carte {3,3} // Voir l'image... positionBlocCarte.x = positionForme.x + i; positionBlocCarte.y = positionForme.y + j; // Si il n'y a aucun obstacle à la position en dessous du bloc et que ce n'est pas la limite de la carte on incrémente flag if (carte[positionBlocCarte.x][positionBlocCarte.y + 1] == 0 && positionBlocCarte.y +1 < NB_BLOCS_HAUTEUR-1 ) flag++; } } } if(flag) return 1; else return 0; }
Pour que ça soit clair pour tout le monde, comme on dit "une photo vaut 1000 mots", j'ai ajouté cette petite illustration pour vous décrire ce que je compte faire.

http://img231.imageshack.us/img231/3043/tetris.jpg

Qu'est ce qui cloche dans mon code ?

Merci.

EDIT:
JE crois avoir trouvé d'où venait le problème. C'est peut-être le flag que j'utilise mal.
J'essaie de trouver une solution. si vous en avez une merci de la partager avec moi ;)

EDIT2 :
Normalement ce code devrai régler le problème du flag:
Code:

1 2 3 4 5 // Si flag = 4, ça veut dire que tous les blocs ont le champs libre pour descendre. if(flag == 4) return 1; else return 0;
Je viens de tester et je m'apercois que mon flag est toujours égale à 1. Je ne vois pas du tout ce qui peut causer ça.

02/08/2009, 14h10
Bruno.C

Je viens de m'apercevoir que j'ai intervertie les variables lors de la déclaraiton de ma fonction.
Je faisais ça

Code:

int carte[][TAILLE_FORME], int carteForme[][NB_BLOCS_HAUTEUR]

au lieu de :

Code:

int carte[][NB_BLOCS_HAUTEUR], int carteForme[][TAILLE_FORME]

Malgrè ça mon problème est toujours d'actualité, la pièce ne s'arrète pas quand il y a collision.
02/08/2009, 14h16
crazymonkey

Le problème ne vient peut être pas de ta fonction collision mais de ta façon de gérer le résultat de cette fonction et donc de stopper la pièce ?

Bah non, c'est bon de ce coté là.
Voila ce que je fais:

Code:

1
2
3
4
5
6
7
8
if((tempsActuel - tempsPrecedent) > 900)
{
    if(verifierCollisionCarte(positionForme, carte, carteForme))
    {
        positionForme.y++;
        tempsPrecedent = tempsActuel;
    }
}

Question capitale : est-ce que ta forme est incluse dans la carte ou pas ? Car si c'est le cas, la fonction va d'office détecter une collision pour la deuxième colonne de ta forme. ^^

Si c'est pas le cas, essaye ça et dis si ça fonctionne :

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
int verifierCollisionCarte(SDL_Rect positionForme, int carte[][NB_BLOCS_HAUTEUR], int carteForme[][TAILLE_FORME])
{
    SDL_Rect positionBlocCarte;
    int i = 0, j = 0, flag = 0;
	int lignemaxi=0, nbrebloc=0;
 
/* on détermine la ligne du bas de l'objet par rapport à la forme */
	for(j = TAILLE_FORME-1; j >=0 ; j--)
	{
		nbrebloc=0;
		for(i = 0; i < TAILLE_FORME ; i++)
		{
			if (carteForme[i][j]==1) nbrebloc++;
		}
		if (nbrebloc!=0) break;
	}
	lignemaxi=j;
	if (positionForme.y+lignemaxi==TAILLE_FORME-1) return 1; /* l'objet est tout en bas du tableau. Au suivant ! */
 
/* on teste les collisions */
    for(i = 0; i < TAILLE_FORME ; i++)
    {
        for(j = 0; j <= lignemaxi ; j++)
        {
            if(carteForme[i][j]==1 && carte[positionBlocCarte.x+i][positionBlocCarte.y+j+1]==1) return 1;
        }
    }
	return 0;
}

EDIT : j'ai fait une grosse gaffe dans mon algo, je viens de corriger (14h45).
EDIT2 : rebelotte... mdr... Corrigé.

02/08/2009, 14h53
Bruno.C

Je n'ai pas très bien compris la question. Mais si tu demande si les blocs pleins de ma pièce apparaissent dans ma carte (des 1 au lieu de zéros) je réponds non. Mais à l'aide d'un calcul simple j'arrive à connaitre la position de chaque bloc de ma ma pièce sur la carte, après il est simple de vérifier si la case suivante sur la carte est pleine ou vide pour bouger.

Sinon pour le code, je ne l'ai pas compris non plus, mais je le test et ça ne donne rien. La pièce reste figée tout au dessus comme si elle avait détectée une collision au tout début.

Merci à vous deux pour votre aide.
02/08/2009, 15h01
jeroman

Citation:

Je n'ai pas très bien compris la question. Mais si tu demande si les blocs pleins de ma pièce apparaissent dans ma carte (des 1 au lieu de zéros) je réponds non.

D'accord.

Citation:

Sinon pour le code, je ne l'ai pas compris non plus, mais je le test et ça ne donne rien. La pièce reste figée tout au dessus comme si elle avait détectée une collision au tout début.

Il s'agit bien du code corrigé (celui de 14h47) ? (j'avais fait deux gaffe dans mon code précédent, j'ai édité deux fois)
02/08/2009, 15h12
Bruno.C

Non toujours le même problème.
J'ai testé chaque bout de ton code à la fois.
D'abord la première partie ne fonctionne pas, puisque la pièce ne s'arrête pas à la limite de la carte. Mais pour ça je n'ai pas torps de problème pûisque mon code fonctionne dans ce cas là.
Et la deuxième partie bloque la pièce tout au dessus de l'écran.

Bon, on récapitule. J'ai encore foiré une ligne du code. Je suis très mal reveillé... :mouarf:

Voici le code à tester :

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
int verifierCollisionCarte(SDL_Rect positionForme, int carte[][NB_BLOCS_HAUTEUR], int carteForme[][TAILLE_FORME])
{
    SDL_Rect positionBlocCarte;
    int i = 0, j = 0, flag = 0;
	int lignemaxi=0, nbrebloc=0;
 
/* on détermine la ligne du bas de l'objet par rapport à la forme */
	for(j = TAILLE_FORME-1; j >=0 ; j--)
	{
		nbrebloc=0;
		for(i = 0; i < TAILLE_FORME ; i++)
		{
			if (carteForme[i][j]==1) nbrebloc++;
		}
		if (nbrebloc!=0) break;
	}
	lignemaxi=j;
	if (positionForme.y+lignemaxi==NB_BLOCS_HAUTEUR-1) return 1; /* l'objet est tout en bas de la carte. Au suivant ! */
 
/* on teste les collisions */
    for(i = 0; i < TAILLE_FORME ; i++)
    {
        for(j = 0; j <= lignemaxi ; j++)
        {
            if(carteForme[i][j]==1 && carte[positionBlocCarte.x+i][positionBlocCarte.y+j+1]==1) return 1;
        }
    }
	return 0;
}

02/08/2009, 15h24
Bruno.C

Toujours le même problème que tout à l'heure :oops:
Merci pour tous ces efforts, mais même si ton code fonctionnait j'ai du mal à le comprendre et je trouve que c'est plus complexe que ce que j'essaye de faire.

Théoriquement, ma fonction devrait fonctionner, mais il y a quelque chose qui cloche et je n'arrive pas à mettre la main dessus.

Donc te serait-il possible stp de voir avec moi ce qui foire dans ma fonction, et si jamais on n'y arrive pas, je serai contraint à ce moment de changer de tactique et de me pencher sur ton code :roll:.
02/08/2009, 15h35
jeroman

Mon code est assez simple.

Dans un premier temps, je cherche à savoir si l'objet (la partie bleue de la forme, dans ton exemple) a bien atteint le bas de la carte.
En fait, je vois la collision d'une manière générique. Si l'objet ne peut pas aller plus bas, c'est qu'il y a collision : soit un autre objet le bloque, soit le "sol" l'arrête (le bas de la carte). Après, je ne sais pas si tu veux gérer ces deux choses à part entière ou non. J'ai fait au plus simple.
Bref. Donc, le code détermine la dernière ligne qui contient du bleu (en gardant ton exemple) dans la forme. Une fois cette ligne trouvée, en l'ajoutant à la position verticale de la forme dans la carte, cela permet de connaître la position verticale de cette dernière ligne dans la carte. Si elle est égale à NB_BLOCS_HAUTEUR-1, c'est qu'elle est arrivée tout en bas de la carte. Donc, je renvois 1, ce qui s'apparente à une collision.

Si ce n'est pas le cas, on teste la collision avec la présence ou non d'autres objets dans la carte, comme tu l'as fait dans ton algo d'origine. J'ai juste un peu simplifié la chose. Dès qu'il y a collision d'un bloc détectée, je renvoie 1 directement, ce qui évite de tester inutilement d'autres éventuelles collisions de blocs.

Au final, si aucune collision n'a été détectée, on renvoie alors 0.
02/08/2009, 15h39
jeroman

Ton code complet est long ou pas ? Le problème se situe peut-être ailleurs ?

Merci pour les explications, en effet vue comme ça c'est plutôt facile. Mais le problème comme toujours c'est de passer de la théorie à la pratique :)

Pour l'instant le code composant mon projet est assez simple et je ne crois pas qu'il y ai une partie qui puisse interagir avec ma fonction verifierCollisionCarte.
La seule difficulté que j'ai eu se situe ici :

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
 
// Faire tourner le tableau contenant la pièce
int tournerForme(int carteForme[][TAILLE_FORME], SDL_Rect pos)
{
    int temp[TAILLE_FORME][TAILLE_FORME] = {0};
    int test = 0, i = 0, j = 0;
 
    if(pos.x+3 < NB_BLOCS_LARGEUR && pos.x > -1 )
    {
        for(i = 0; i < TAILLE_FORME; i++)
        {
            for(j = 0; j < TAILLE_FORME; j++)
            {
                test =  (int) fabs(j - 2);
                temp[test][i] = carteForme[i][j] ; //j1 = i2 and i1 = |j2 - 3|
            }
        }
        for(i = 0; i < TAILLE_FORME; i++)
        {
            for(j = 0; j < TAILLE_FORME; j++)
            {
                  carteForme[i][j] = temp[i][j]; //j1 = i2 and i1 = |j2 - 3|
            }
        }
    }
    return carte;
}

Mais je doute que cela soit la cause de mon problème.

02/08/2009, 16h21
jeroman

Code:

test = (int) fabs(j - 2);

Attention, fabs gère les types double, ce qui peut provoquer un soucis lors des conversions. Utilise plutôt la fonction abs (définie dans stdlib.h), qui gère le type int.
Si ce "2" correspond bien à TAILLE_FORME-1, tu peux même simplifier en remplaçant la ligne par :

Code:

test=TAILLE_FORME-j;

, ce qui revient au même.

Bon, sinon, c'est sûr que ça ne règle pas le soucis concernant l'histoire de la collision.
02/08/2009, 16h42
Bruno.C

Merci en effet, écrire test = TAILLE_FORME-j-1; reviens au même.

PS: j'ai ajouté un -1, car TAILLE_FORME = 3.

Citation:

Merci en effet, écrire test = TAILLE_FORME-j-1; reviens au même.

PS: j'ai ajouté un -1, car TAILLE_FORME = 3.

Exact ! :lol:

Bon, finalement, j'avais encore oublié de modifier un truc dans l'algo. Pour tester, de manière non hasardeuse cette fois-ci, j'ai fait un petit code en mode console pour vérifier si ça marche bien. Et chez moi, ça tourne impec.

Voilà l'algo corrigé à nouveau (désolé, j'espère que je t'embrouille pas trop... lol) :

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
int verifierCollisionCarte(SDL_Rect positionForme, int carte[][NB_BLOCS_HAUTEUR], int carteForme[][TAILLE_FORME])
{
    int i = 0, j = 0;
	int lignemaxi=0, nbrebloc=0;
 
/* on détermine la ligne du bas de l'objet par rapport à la forme */
	for(j = TAILLE_FORME-1; j >=0 ; j--)
	{
		nbrebloc=0;
		for(i = 0; i < TAILLE_FORME ; i++)
		{
			if (carteForme[i][j]==1) nbrebloc++;
		}
		if (nbrebloc!=0) break;
	}
	lignemaxi=j;
	if (positionForme.y+lignemaxi==NB_BLOCS_HAUTEUR-1) return 1; /* l'objet est tout en bas de la carte. Au suivant ! */
 
/* on teste les collisions */
    for(i = 0; i < TAILLE_FORME ; i++)
    {
        for(j = 0; j <= lignemaxi ; j++)
        {
            if(carteForme[i][j]==1 && carte[positionForme.x+i][positionForme.y+j+1]==1) return 1;
        }
    }
	return 0;
}

Pour tester, voici mon programme (en mode console) :

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
#include <stdio.h>
#include <stdlib.h>
 
#define TAILLE_FORME 3
#define NB_BLOCS_HAUTEUR 10
 
/* pour éviter d'importer la SDL */
typedef struct
{
 int x,y;
} SDL_Rect;
/* --- */
 
int verifierCollisionCarte(SDL_Rect positionForme, int carte[][NB_BLOCS_HAUTEUR], int carteForme[][TAILLE_FORME])
{
    int i = 0, j = 0;
	int lignemaxi=0, nbrebloc=0;
 
/* on détermine la ligne du bas de l'objet par rapport à la forme */
	for(j = TAILLE_FORME-1; j >=0 ; j--)
	{
		nbrebloc=0;
		for(i = 0; i < TAILLE_FORME ; i++)
		{
			if (carteForme[i][j]==1) nbrebloc++;
		}
		if (nbrebloc!=0) break;
	}
	lignemaxi=j;
	if (positionForme.y+lignemaxi==NB_BLOCS_HAUTEUR-1) return 1; /* l'objet est tout en bas de la carte. Au suivant ! */
 
/* on teste les collisions */
    for(i = 0; i < TAILLE_FORME ; i++)
    {
        for(j = 0; j <= lignemaxi ; j++)
        {
            if(carteForme[i][j]==1 && carte[positionForme.x+i][positionForme.y+j+1]==1) return 1;
        }
    }
	return 0;
}
void affichage(int carte[][NB_BLOCS_HAUTEUR], int forme[][TAILLE_FORME])
{
	int x,y,a;
	SDL_Rect positionForme;
 
	printf("Forme :\n\n");
	for (y=0; y<TAILLE_FORME; y++)
	{
		for (x=0; x<TAILLE_FORME; x++)
		{
			printf("%d",forme[x][y]);
		}
		printf("\n");
	}
	printf("\nCarte :\n\n");	
	for (y=0; y<NB_BLOCS_HAUTEUR; y++)
	{
		printf("Ligne %d : ",y);
		for (x=0; x<TAILLE_FORME; x++)
		{
			printf("%d",carte[x][y]);
		}
		printf("\n");
	}
	printf("\n\n");
 
	positionForme.x=0;
	positionForme.y=0;
 
	for (a=0; a<NB_BLOCS_HAUTEUR; a++)
	{
		positionForme.y=a;
		printf("Position de la forme, ligne %d : ",a);
		if (verifierCollisionCarte(positionForme,carte,forme)==0)
			printf("Pas de collision");
		else
		{
			printf("Collision");
			break;
		}
		printf("\n");
	}
}
int main(void)
{
	int forme1[TAILLE_FORME][TAILLE_FORME]={
	0,1,0,
	1,1,0,
	0,1,0
	};
	int forme2[TAILLE_FORME][TAILLE_FORME]={
	0,0,0,
	0,1,0,
	1,1,1
	};
 
	int carte[TAILLE_FORME][NB_BLOCS_HAUTEUR]={0};
 
	printf("*** Test 1 : Sans autre objet ***\n\n");
	affichage(carte,forme1);
 
	printf("\n\nAppuyez sur une touche\n\n");
	getchar();
 
	printf("\n\n\n\n*** Test 2 : Avec un objet en bas ***\n\n");
	carte[0][NB_BLOCS_HAUTEUR-1]=1;
	carte[1][NB_BLOCS_HAUTEUR-1]=1;
	carte[2][NB_BLOCS_HAUTEUR-1]=1;
	carte[1][NB_BLOCS_HAUTEUR-2]=1;
	affichage(carte,forme1);
 
	printf("\n\nAppuyez sur une touche\n\n");
	getchar();
 
	printf("\n\n\n\n*** Test 3 : Avec un objet en bas ***\n\n");
	carte[0][NB_BLOCS_HAUTEUR-1]=1;
	carte[1][NB_BLOCS_HAUTEUR-1]=0;
	carte[2][NB_BLOCS_HAUTEUR-1]=0;
	carte[0][NB_BLOCS_HAUTEUR-2]=1;
	carte[0][NB_BLOCS_HAUTEUR-3]=1;
	affichage(carte,forme2);
 
	printf("\n\n");
	system("pause");
	return 0;
}

Donc, si cela ne marche toujours pas, il y a fort probablement un soucis ailleurs...

Non ça ne fonctionne toujours pas. comme tu dis, il doit y avoir un problème quelque part dans mon code.

Je te passe mon main.c, peut être que tu y détectera une anomalie en espérant que ce soit le cas, car je commence vraiment à perdre espoir :cry:.

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
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
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL_image.h>
 
#include "constantes.h"
#include "formes.h"
#include "event.h"
 
int main(int argc, char *argv[])
{
    SDL_Surface *ecran = NULL, *carreBlanc = NULL, *carreBleu = NULL, *carreJaune = NULL, *carreRouge = NULL, *carreVert = NULL, *carreViolet = NULL, *carreOrange = NULL, *temoin = NULL;
    SDL_Event event;
    SDL_Rect positionCarre[4], positionForme, positionCarte, positionTemoin;
    Input in;
 
    int continuer = 1, carte[LARGEUR_ECRAN][HAUTEUR_ECRAN] = {0}, carteForme[TAILLE_FORME][TAILLE_FORME] = {0}, i = 0, j = 0, z = 0;
    int tempsActuel = 0, tempsPrecedent = 0, gagne = 0, collision = 0;
 
    SDL_Init(SDL_INIT_VIDEO);
 
    ecran = SDL_SetVideoMode(LARGEUR_ECRAN, LARGEUR_ECRAN, 32, SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_RESIZABLE);
    SDL_WM_SetCaption("Tetriiiiis !", NULL);
 
    carreBlanc = IMG_Load("images\\blanc.jpg");
    carreBleu = IMG_Load("images\\bleu.jpg");
    carreJaune = IMG_Load("images\\jaune.jpg");
    carreRouge = IMG_Load("images\\rouge.jpg");
    carreVert = IMG_Load("images\\vert.jpg");
    carreViolet = IMG_Load("images\\violet.jpg");
    carreOrange = IMG_Load("images\\orange.jpg");
    temoin = IMG_Load("images\\temoin.jpg");
 
    // Pour tester les collisions je place quelques blocs dans la carte
    carte[NB_BLOCS_LARGEUR / 2][NB_BLOCS_HAUTEUR - 1] = 1;
    carte[(NB_BLOCS_LARGEUR / 2 )- 1][NB_BLOCS_HAUTEUR - 2] = 1;
    carte[(NB_BLOCS_LARGEUR / 2) -  1][NB_BLOCS_HAUTEUR - 1] = 1;
    carte[(NB_BLOCS_LARGEUR / 2) - 1][NB_BLOCS_HAUTEUR - 3] = 1;
 
    // On initalise la position de la forme
    positionForme.x = (NB_BLOCS_LARGEUR / 2) - 2  ;
    positionForme.y = -2;
 
    // on génére une forme
    creerForme(carteForme);
 
    SDL_EnableKeyRepeat(100, 100);
 
    memset(&in, 0, sizeof(in));
    while(!in.key[SDLK_ESCAPE] && !in.quit)
    {
        UpdateEvents(&in);
        tempsActuel = SDL_GetTicks();
        if((tempsActuel - tempsPrecedent) > 900)
        {
            if(verifierCollisionCarte(positionForme, carte, carteForme))
            {
                positionForme.y++;
                tempsPrecedent = tempsActuel;
            }
        }
        else
        {
            SDL_Delay(1);
        }
        if(in.key[SDLK_UP])
        {
            tournerForme(carteForme, positionForme);
            in.key[SDLK_UP] = 0;
        }
 
        if(in.key[SDLK_DOWN] && verifierCollisionCarte(positionForme, carte, carteForme))
        {
                positionForme.y++;
                in.key[SDLK_DOWN] = 0;
        }
        if(in.key[SDLK_LEFT])
        {
            positionForme.x--;
            in.key[SDLK_LEFT] = 0;
        }
        if(in.key[SDLK_RIGHT])
        {
            positionForme.x++;
            in.key[SDLK_RIGHT] = 0;
        }
        if(in.key[SDLK_SPACE])
        {
            tournerForme(carteForme, positionForme);
            in.key[SDLK_SPACE] = 0;
        }
 
 
        if(!gagne)
        {
//            positionTemoin.x = positionForme.x * TAILLE_BLOC;
//            positionTemoin.y = positionForme.y * TAILLE_BLOC;
//            SDL_BlitSurface(temoin, NULL, ecran, &positionTemoin);
            z =0;
            for (i = 0; i < TAILLE_FORME; i++)
            {
                for (j = 0; j < TAILLE_FORME; j++)
                {
                    if (carteForme[i][j])
                    {
                        positionCarre[z].x = (positionForme.x + i)  * TAILLE_BLOC;
                        positionCarre[z].y = (positionForme.y + j)  * TAILLE_BLOC;
 
                        // On blite le carrés selon la couleur
                        switch(carteForme[i][j])
                        {
                            case BLANC:
                                SDL_BlitSurface(carreBlanc, NULL, ecran, &positionCarre[z]);
                                break;
                            case BLEU:
                                SDL_BlitSurface(carreBleu, NULL, ecran, &positionCarre[z]);
                                break;
                            case JAUNE:
                                SDL_BlitSurface(carreJaune, NULL, ecran, &positionCarre[z]);
                                break;
                            case VERT:
                                SDL_BlitSurface(carreVert, NULL, ecran, &positionCarre[z]);
                                break;
                            case VIOLET:
                                SDL_BlitSurface(carreViolet, NULL, ecran, &positionCarre[z]);
                                break;
                            case ROUGE:
                                SDL_BlitSurface(carreRouge, NULL, ecran, &positionCarre[z]);
                                break;
                            case ORANGE:
                                SDL_BlitSurface(carreOrange, NULL, ecran, &positionCarre[z]);
                                break;
                        }
 
                    }
 
                }
            }
            for (i = 0; i < NB_BLOCS_LARGEUR; i++)
            {
                for (j = 0; j < NB_BLOCS_HAUTEUR; j++)
                {
                    if(carte[i][j])
                    {
                        positionCarte.x = i * TAILLE_BLOC;
                        positionCarte.y = j * TAILLE_BLOC;
                        SDL_BlitSurface(carreOrange, NULL, ecran, &positionCarte);
                    }
                }
            }
        }
 
        SDL_Flip(ecran);
        SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255,255,255));
    }
 
    return 0;
 
}

Il ya quelques variables inutilisées et d'autres qui ne sont là que poureffectuer des testes donc n'y prête pas trop attention.

02/08/2009, 19h42
jeroman

Il faudrait tous les fichiers, car il n'y a pas moyen de tester sinon (ça ne peut pas compiler).
02/08/2009, 19h51
Bruno.C

Citation:

Envoyé par jeroman

Il faudrait tous les fichiers, car il n'y a pas moyen de tester sinon (ça ne peut pas compiler).

Ce n'est plus la peine, car j'ai réglé mon problème.
tu avais raison, ma fonction était correcte, le problème était ailleurs.

C'était vraiment con comme erreur, mais grâce à un forumiste par mp il a réussit à dénicher l'erreur.
En fait c'était à cause de la déclaration de "carte[][]". Il fallait que je fasse:

Code:

carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};

Ouf, je vais pouvoir passer à autre chose.
Merci à vous tous qui avez essayé de m'aider, je l'apprécie vraiment.

Mention spéciale à jeroman, qui a prit de son temps et à même codé sa propre fonction et fait des testes pour m'aider et à SofEvans qui a eu l'oeil pour dénicher cette erreur.