Discussion :

[DePierre]

Bonjour à toutes et à tous,

J'essaye ces derniers temps de me familiariser avec la SDL.
A la suite d'une discussion avec Virdiss, j'ai voulu faire passer mon tetris, jusqu'à alors en mode console, en mode graphique via la SDL.

Malheureusement, j'ai un problème pour faire descendre mon puits lorsqu'une ligne est pleine.


Situation :

J'ai une structure qui représente le champ de jeu. Elle contient un tableau d'int de taille 22*12, et un tableau de SDL_Surface, qui représente l'affichage de ce champs.

Lorsque j'appelle la fonction qui est censée descendre le puits d'une ligne, la matrice d'int est correcte, mais l'affichage ne l'est pas.
Chaque ligne en partant du bas deviennent noires tour à tour.


(Fonction descendant les lignes)

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
 
//coorLine vaut la coordonnée suivant Y (affichage) (x suivant la matrice) de la ligne vide
//coorTop vaut la coordonnée suivant Y (affichage) (x suivant la matrice) de la prochaine ligne vide ou du haut du puit
void downWell(Field *F, int coorLine, int coorTop)
{
    int k, i, j;
    SDL_Rect position;
 
    for(i=0; i<FLENGTH; i++)
        {
            for(j=0; j<FWIDTH; j++)
                printf("%d", F->F_Matrix[i][j]);
            printf("\n");
        }
        printf("\n");
 
    for(k=coorLine; k>coorTop-1; k--)
    {
        for(i=1; i<FWIDTH-1; i++)
            F->F_Matrix[k][i] = F->F_Matrix[k-1][i];
 
        for(i=0; i<FLENGTH; i++)
        {
            for(j=0; j<FWIDTH; j++)
                printf("%d", F->F_Matrix[i][j]);
            printf("\n");
        }
        printf("\n");
 
        position.y = TETRISX + (k)*10;
        for(i=1; i<FWIDTH-1; i++)
        {
            position.x = TETRISY + i*10;
            *F->F_RectMatrix[k][i] = *F->F_RectMatrix[k-1][i];
            SDL_BlitSurface(F->F_RectMatrix[k][i], NULL, F->F_pScreen, &position);
        }
    }
}

(Fonction vidant les lignes pleines)

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
 
void eraseFilledLines(Field *F, int coorFilledLines[], int L)
{
    int k, i;
    SDL_Rect position;
 
    for(k=0; k<L-1; k++)
    {
        for(i=1; i<FWIDTH-1; i++)
            F->F_Matrix[coorFilledLines[k]][i] = EMPTY;
 
 
        for(i=1; i<FWIDTH-1; i++)
        {
            position.y = TETRISX + coorFilledLines[k]*10;
            position.x = TETRISY + i*10;
 
            SDL_FillRect(F->F_RectMatrix[coorFilledLines[k]][i], NULL, SDL_MapRGB(F->F_pScreen->format, F->F_BackgroundColorRGB[0], F->F_BackgroundColorRGB[1], F->F_BackgroundColorRGB[2]));
            SDL_BlitSurface(F->F_RectMatrix[coorFilledLines[k]][i], NULL, F->F_pScreen, &position);
        }
    }
 
    for(k=0; k<L-1; k++)
        downWell(F,coorFilledLines[k], coorFilledLines[k+1]);
}

(Structure Field)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
struct Field
{
    int F_Matrix[FLENGTH][FWIDTH];
    SDL_Surface *F_RectMatrix[FLENGTH][FWIDTH];
 
    int F_TopWell;
 
    int F_BackgroundColorRGB[3];
    int F_BorderColorRGB[3];
 
    SDL_Surface *F_pScreen; //Pointeur sur l'écran principal
};

(Constantes)

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
 
//Field constants
    #define X0 1
    #define Y0 5
 
    #define FWIDTH 12
    #define FLENGTH 22
 
    #define TETRION 0
    #define EMPTY 1
    #define WELL 2
    #define BLOCK 3
 
    //Block constants
    #define X 0
    #define Y 1
 
    #define NBCOOR 4
 
    //Collisions constants
    #define FIXED -1
    #define MOVIMP 0
    #define MOVOK 1
 
    //Display constants
    #define BWIDTH 10
 
    //MainWindow constants
    #define MWWIDTH 480
    #define MWLENGTH 640
 
    #define TETRISY 100
    #define TETRISX 10
 
    //BOOLEAN
    #define TRUE 1
    #define FALSE 0

(Exemple du déroulement de la fonction downWell appliquée à la matrice d'int)

Code :

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

1
2
3
4
5
6
7
8
9
 
011111111110        011111111110        011111111110        011111111110        011111111110
011111111220        011111111220        011111111220        011111111220        011111111110
011111111220        011111111220        011111111220        011111111220        011111111220
011222112220        011222112220        011111111220        011111111220        011111111220
011111111110        011222112220        011222112220        011222112220        011222112220
000000000000        000000000000        000000000000        000000000000        000000000000
 
(Avec 0 = Bordure, 1 = Vide, 2 = Piece fixe)

Mais à l'affichage, j'ai mes lignes du bas qui deviennent noires une par une.

Je ne comprends pas ce qui est faux dans mon code, dont voici le lien de téléchargement : http://www.fileswap.com/dl/3IpMJktE/...GUIV3.zip.html
L'erreur devrait se trouver dans le fichier field.c, ligne ~231 il semblerait.

Pourquoi l'affichage est-il mauvais alors qu'il suit le même algorithme que pour la matrice d'int, qui est correct.

Pourriez-vous m'aider ? Sauriez-vous me dire ce que je n'ai pas saisi avec la SDL ?

Merci.

[DePierre]

Petit up.

J'en profite aussi pour ajouter que si je modifie la ligne

Code :

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

*F->F_RectMatrix[k][i] = *F->F_RectMatrix[k-1][i];

en (à simple titre d'exemple)

Code :

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

*F->F_RectMatrix[k][i] = *F->F_RectMatrix[k][i];

Normalement, l'affichage ne devrait pas changer, puisque la ligne k "se reçoit" elle-même. Pourtant, les lignes deviennent quand même noires.

Mais aussi, si je modifie maintenant la ligne en

Code :

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

*F->F_RectMatrix[k][i] = *F->F_RectMatrix[k+1][i];

J'ai bien mon puits qui devient gris vu que :
-la ligne vide reçoit la ligne d'en dessous, qui est celle représentant la bordure et qui est grise
-la ligne du dessus, reçoit celle d'en dessous, qui est maintenant grise
-etc.

Donc pourquoi, si avec k+1 mon puits devient gris, avec k-1, tout devient noir...

Quelqu'un pourrait-il m'éclairer sur ces deux remarques ainsi que si ma question initiale ?

Merci.