[T�tris]Bug de code

Version imprimable

[T�tris]Bug de code

Bonjour

Je suis en train de coder mon propre t�tris et je suis face � un dr�le de probl�me.

Lorsque le bloc arrive, il tombe normalement:
http://upload.404home.com/files/thum...1197387459.png

Mais lorsqu'il a touch� le "sol", une copie de ce bloc se place au milieu du jeu.
(Je pense que le bloc est plac� en Y avec les coordonn�es de X).
Voici une petite image montrant le probl�me:
http://upload.404home.com/files/thum...1197387459.png
(Le carr� du haut est l'intrus).

Voici le code utilis� pour g�n�rer les coordonn�es du bloc:

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
case 2:  //Case 2 == CARRE
/*
pos est de type SDL_Rect et est un tableau de 4 cases.  Il contient les coordonnées du bloc en train de tomber.
*/
        case 2:  //Carré
        if(carte[pos[2].x][pos[2].y+1] == 0 && carte[pos[3].x][pos[3].y+1] == 0
        && (pos[2].y+1) < NB_BLOCS_H){
            for(int i=0;i<4;i++){
                pos[i].y++;
            }
        }
        if(pos[2].y+1 == NB_BLOCS_H || carte[pos[2].x][pos[2].y+1] != 0
        || carte[pos[3].x][pos[3].y+1] != 0){
            carte[x_1][y_1] = 4;
            carte[pos[1].x][pos[1].y] = 4;
            carte[pos[2].x][pos[2].y] = 4;
            carte[pos[3].x][pos[3].y] = 4;
            pos[0].x = -1;
            pos[0].y = -1;
            pos[1].x = -1;
            pos[1].y = -1;
            pos[2].x = -1;
            pos[2].y = -1;
            pos[3].x = -1;
            pos[3].y = -1;
            etat = true;
 
        }
        break;

Voici le code qui colle les images � l'�cran:

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
//Blittage du décor
    for(int i=0;i<NB_BLOCS_L;i++){
        for(int j=0;j<NB_BLOCS_H;j++){
            position.x = i*TAILLE_BLOC;
            position.y = j*TAILLE_BLOC;
            switch(carte[i][j]){
                case 0:
                SDL_BlitSurface(vide, NULL, ecran, &position);
                break;
                case 1://Ligne
                SDL_BlitSurface(jaune, NULL, ecran, &position);
                break;
                case 2://Bloc
                SDL_BlitSurface(rouge, NULL, ecran, &position);
                break;
//Pour l'instant, seul 2 "case" sont faits.
            }
           //Blittage du bloc en cours de descente
            for(int alpha=0;alpha<4;alpha++){
                if(pos_piece[alpha].x == i && pos_piece[alpha].y == j){
                    position.x = i*TAILLE_BLOC;
                    position.y = j*TAILLE_BLOC;
                    SDL_BlitSurface(jaune, NULL, ecran, &position);
                }
            }//Fin du "for"
        }
    }

Ou est le probl�me?

Merci d'avance.

11/12/2007, 18h45
darrylsite

je crois qu' il sera un peu difficile de t' aider. Tu ne commentes meme pas le code incomplet que tu nous donnes. On ne peut pas vraiment deviner ce que tu veux que le programme faisse. Ni quelle methode tu utilis�e pour construire le programme.

Citation:

switch(carte[i][j]){
case 0:

Le 0 signifie quoi ?

En fait, chaque bloc est un nombre de 1 � 7 (il y a 7 blocs). Les coordonn�es de ce bloc sont stock�es dans une variable de type SDL_Rect. (Dans la fonction, elle s'appelle "pos[]" et c'est un tableau de 4 (il y a 4 blocs dans chaque figure).

Une fonction se charge donc de faire descendre le bloc et tout se passe parfaitement.

Ensuite, si le bloc ne peut plus descendre (s'il est arriv� au bas de l'�cran ou a touch� un autre bloc), LE BLOC EST ECRIT DANS LA VARIABLE "carte" qui est un tableau de int.

Dans la boucle principale, il suffit juste d'afficher le contenu de la varialbe carte
(carte[i][j] est le num�ro de la case parcourue par la boucle).
Dans mon code, 0 vaut "vide", un fond vide est donc affich�.
Suivant le nombre que c'est, un bloc d'une couleur X ou Y est "Blitt�".

Le probl�me est que lorsque le bloc s'arr�te, il s'affiche correctement, mais un autre bloc intrus apparait ET RESTE QUOI QU'IL SE PASSE!!!8O
(le carr� sup�rieur du secont PrintScreen).

Les fonctions de descente et d'affichange sont dans une classe nomm�e bloc.
Voici l'entieret� de ma fonction "descente" (elle n'est pas termin�e) qui se charge, si le bloc ne peut plus descendre, de le "fixer" dans la variable "carte".

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
 
bool bloc::descente(SDL_Rect *pos, int piece, int carte[][NB_BLOCS_L]){
    bool etat = false;
 
    switch(piece){
        case 1://Barre horizontale
        if(carte[pos[0].x][pos[0].y+1] == 0 && carte[pos[1].x][pos[1].y+1] == 0
        && carte[pos[2].x][pos[2].y+1] == 0 && carte[pos[3].x][pos[3].y+1] == 0
        && pos[0].y+1 < NB_BLOCS_H){
            for(int i=0;i<4;i++){
                pos[i].y++;
            }
        }
        if(pos[0].y+1 == NB_BLOCS_H){
            for(int i=0;i<4;i++){
                carte[pos[i].x][pos[i].y] = 1;
            }
            //Piochage d'un nouveau bloc
            etat = true;
        }
        break;
        case 2:  //Carré
        if(carte[pos[2].x][pos[2].y+1] == 0 && carte[pos[3].x][pos[3].y+1] == 0
        && (pos[2].y+1) < NB_BLOCS_H){
            for(int i=0;i<4;i++){
                pos[i].y++;
            }
        }
        if(pos[2].y+1 == NB_BLOCS_H){
            for(int i=0;i<4;i++){
                carte[pos[i].x][pos[i].y] = 2;
            }
            //Piochage d'un nouveau bloc
            etat = true;
        }
        break;
        case 3: //T
        if(carte[pos[0].x][pos[0].y+1] == 0 && carte[pos[2].x][pos[2].y+1] == 0
        && carte[pos[3].x][pos[3].y+1] == 0 && pos[3].y+1 < NB_BLOCS_H){
            for(int i=0;i<4;i++){
                pos[i].y++;
            }
        }
        if(pos[3].y+1 == NB_BLOCS_H || carte[pos[3].x][pos[3].y+1] !=0
        || carte[pos[0].x][pos[0].y+1] != 0 || carte[pos[2].x][pos[2].y+1] != 0){
            for(int i=0;i<4;i++){
                carte[pos[i].x][pos[i].y] = 3;
            }
            //Piochage d'un nouveau bloc
            etat = true;
        }
        break;
        case 4:
        if(carte[pos[2].x][pos[2].y+1] == 0 && carte[pos[3].x][pos[3].y+1] == 0
        && pos[3].y+1 < NB_BLOCS_H){
            for(int i=0;i<4;i++){
                pos[i].y++;
            }
        }
        if(pos[2].y+1 == NB_BLOCS_H || carte[pos[2].x][pos[2].y+1] != 0
        || carte[pos[3].x][pos[3].y+1] != 0){
            for(int i=0;i<4;i++){
                carte[pos[i].x][pos[i].y] = 4;
            }
            //Piochage d'un nouveau bloc
            etat = true;
        }
        break;
        case 5:
        if(carte[pos[2].x][pos[2].y+1] == 0 && carte[pos[3].x][pos[3].y+1] == 0
        && pos[3].y+1 < NB_BLOCS_H){
            for(int i=0;i<4;i++){
                pos[i].y++;
            }
        }
        if(pos[2].y+1 == NB_BLOCS_H || carte[pos[2].x][pos[2].y+1] != 0
        || carte[pos[3].x][pos[3].y+1] != 0){
            for(int i=0;i<4;i++){
                carte[pos[i].x][pos[i].y] = 5;
            }
            //Piochage d'un nouveau bloc
            etat = true;
        }
        break;
    }
 
 
 
    return etat;
}

La variable de type bool qui est renvoy�e indique simplement s'il faut ou non s�lectionner une nouvelle piece.
-Le code n'est pas optimis�, j'ai trouv� un moyen plus rapide que 3 boucles pour "fixer" le bloc qui descend dans la varialbe "carte", mais je n'ai pas encore eu le temps de changer.

Voici maintenant une partie de la fonction "jouer" qui se charger de g�rer...tout le jeu:D

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
 
//Descente de la piece:(appel de la fonction descente donnée ci-dessus).
    forme_posee = piece.descente(pos_piece, piece, carte);
/*
pos_piece est le tableau de SDL_Rect contenant la position de la piece
piece est le type de pièce qui est en train de descendre
carte est le tableau de int contenant toute la carte du jeu
*/
 
 
    /*Blittage du menu(il n'est pas terminé et n'est qu'un simple morceau rouge!)*/
    SDL_FillRect(menu, NULL, SDL_MapRGB(ecran->format, 255, 0, 0));
    pos_menu.y = 0;
    pos_menu.x = (NB_BLOCS_L * TAILLE_BLOC);
    SDL_BlitSurface(menu, NULL, ecran, &pos_menu);
 
    /*Blittage du décor (double boucle pour parcourir toute l'étendu de la variable carte[NB_BLOCS_L][NB_BLOCS_H]*/
    for(int i=0;i<NB_BLOCS_L;i++){
        for(int j=0;j<NB_BLOCS_H;j++){
           //Création des différentes positions pour tous les blocs
            position.x = i*TAILLE_BLOC;
            position.y = j*TAILLE_BLOC;
 
           //Parcours de la carte et affichage de ce qu'elle contient
            switch(carte[i][j]){
                case 0://Si la carte est vide
                SDL_BlitSurface(vide, NULL, ecran, &position);
                break;
 
                //Les différents nombres servent à afficher différentes couleurs.
                case 1:
                SDL_BlitSurface(jaune, NULL, ecran, &position);
                break;
                case 2:
                SDL_BlitSurface(rouge, NULL, ecran, &position);
                break;
                case 3:
                SDL_BlitSurface(bleu, NULL, ecran, &position);
                break;
                case 4:
                SDL_BlitSurface(vert, NULL, ecran, &position);
                break;
                case 5:
                SDL_BlitSurface(mauve, NULL, ecran, &position);
                break;
            }
 
 
            //Blittage de la pièce qui descend
            for(int alpha=0;alpha<4;alpha++){
                if(pos_piece[alpha].x == i && pos_piece[alpha].y == j){
                    position.x = i*TAILLE_BLOC;
                    position.y = j*TAILLE_BLOC;
                    SDL_BlitSurface(jaune, NULL, ecran, &position);
                }
            }//Fin du "for"
        }
    }

Voil�, j'esp�re que je me suis bien exprim�:P

Merci de votre aide.

EDIT: le code qui place le bloc dans la variable "carte" a �t� quelque peu am�lior� mais le probl�me reste le m�me.

12/12/2007, 02h12
Pacorabanix

Citation:

Le probl�me est que lorsque le bloc s'arr�te, il s'affiche correctement, mais un autre bloc intrus apparait ET RESTE QUOI QU'IL SE PASSE!!!
(le carr� sup�rieur du secont PrintScreen).

Est ce que le jeu interagit avec le bloc, c'est-�-dire est ce juste un affichage parasite ou peux tu poser les nouveaux blocs dessus ?
12/12/2007, 12h08
chindit

Les nouveaux blocs qui tombent se "fixent" sur ce bloc.
Voici un petit sh�ma annot� qui explique las bugs:
http://upload.404home.com/files/thum...1197457657.png

(J'ai trac� des lignes rouges pour que vous voyez bien la s�paration des blocs.)
14/12/2007, 12h33
30barrett40

Bonjour,
ce que je ferai, c'est que je regarderai que la coordonn�e de X pour savoir � quel endroit il est tomb�, avec la d�tection de collision quand il tombe, puis je le fixerai dans une carte interm�diaire.
Utilise plus le c�t� POO du C++, je te dirai de tout g�rer les blocs dans une classe � eux, puis de faire une classe pour le jeu avec ses donn�es personnelles, c'est ce que j'ai fait pour mon t�tris (si je retrouve le code, je te le montre.).

A plus.

J'ai d�couvert qqch de curieux:
Voici les coordonn�es des 4 blocs au moment o� ils ont touch� le "sol":

Citation:

8 29
9 29
10 29
11 29

et voici les coordonn�es auxquelles ont �t� blitt�es des blocs:

Citation:

BLIT 8 29
BLIT 9 9
BLIT 9 29
BLIT 10 9
BLIT 10 29
BLIT 11 9
BLIT 11 29
BLIT 12 9

J'ai essay� de faire mon "case" le plus simple possible, mais je ne vois toujours pas pourquoi �a bugge.
Revoici le "case" du bloc qui tombait � ce moment:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 case 1: //Si c'est une barre: if(carte[pos[0].x][pos[0].y+1] == 0 && carte[pos[1].x][pos[1].y+1] == 0 && carte[pos[2].x][pos[2].y+1] == 0 && carte[pos[3].x][pos[3].y+1] == 0 && pos[0].y+1 < NB_BLOCS_H){ for(int i=0;i<4;i++){ pos[i].y++; } } else{ for(int i=0;i<4;i++) { carte[pos[i].x][pos[i].y] = 1; pos[i].x=-1; pos[i].y=-1; } //Piochage d'un nouveau bloc forme = true; } break;
@30barrett40:
Que veux-tu dire par "une carte interm�diaire"?

16/12/2007, 13h38
Pacorabanix
LEs r�sultats du d�bug que tu as fait (affichage des blits) sont int�ressants : cela veut, je pense, surement dire que le probl�me est au moment ou la variable carte est �crite :

Citation:

Envoy� par chindit

Ensuite, si le bloc ne peut plus descendre (s'il est arriv� au bas de l'�cran ou a touch� un autre bloc), LE BLOC EST ECRIT DANS LA VARIABLE "carte" qui est un tableau de int.

o� est la partie du code qui teste si cette variable :
Code:

1 2 3 //Descente de la piece:(appel de la fonction descente donnée ci-dessus). forme_posee = piece.descente(pos_piece, piece, carte);
est true ? (et donc je suppose que tu �cris dans carte[][] � ce moment l�).

La pi�ce qui tombe est �crite dans la variable carte dans le "case" de la fonction qui teste si le bloc peut encore descendre (cf message pr�c�dent pour le code).

Depuis que j'ai post� le message pr�c�dent, la fonction ne renvoie plus la variable bool mais la modifie en tant que r�f�rence (ce qui ne change pas beaucoup).

Voici la partie qui teste si la variable vaut "true" et qui s�lectionne une nouvelle pi�ce. Mais je ne vois pas en quoi ce "if" pourrait �tre � l'origine du bug!
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 new_time = SDL_GetTicks(); if(new_time - old_time > delai){ //SI assez de temps s'est écoulé, activation des fonctions //Couleur de fond de l'écran == NOIR SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0)); if(forme_posee){ //Si on peut choisir une nouvelle pièce piece_future = piece.select_forme(); //Sélection de la pièce forme_posee = false; //Mise à "false" de la variable de sélection piece.place_bloc(pos_piece, piece_future); //Préparation des coordonnées initiales du bloc }

16/12/2007, 19h17
30barrett40

Au lieu d'utiliser une variable carte comme tu la d�finie, fais un tableau petit avec lors de la conversion pour l'image une constante correspondant � la largeur d'un bloc.

Pour s�lectionner un nouveau bloc, copie l'�cran actuel dans une surface temporaire. Sinon, je ne vois pas pourquoi :(