Discussion :

[jasinski13]

Bonjour, je réalise un trétris, je suis à la fin du projet cependant je n'arrive pas à trouver la bonne chose pour bloquer mes pièce.
en supposant que mes pièce sont un tableau de int: int[orientation][x][y] tableau, une pièce est créé de 4 sur 4 ( une unité correspond à 20 px ).
mon aire de jeu corrsepond à un tableau de 10 unité sur 20. sachant que si aireDeJeu[][] = 0 ==> case blanche et si aireDeJeu[][] = 1 ==> case noir. voici mes classes:
mon but est d'interrompre mon Thread dans le méthode Run quand ça rencontre un 1/ voici mes classes utiles à cette réalisation:

classe ECRAN:

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
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
/**
 * La classe ecran sera l'ecran sur lequel les figures apparaitrons.
 */
public class Ecran extends JPanel
{
    int [][] aireDeJeu;
    Figure f;
    Figure t;
    private int i;
    public Ecran()
    {
        super();
        aireDeJeu = new int[10][21];
        for(int i = 0;i<10;i++)
        {
            for(int j=0;j<19;j++)
            {
                aireDeJeu[i][j]=0;
            }
        }
        aireDeJeu[5][15]=1;
        aireDeJeu[8][4]=1;
        aireDeJeu[6][12]=1; 
        for(int i = 0;i<10;i++)
        {
            aireDeJeu[i][20] = 1;
        }
        f = new T();
        this.add(f);
        t = new Figure(aireDeJeu);     
 
        destroy();
    }
 
    public void destroy()
    {
        int somme = 0;
        for(int i =0; i<10; i++)
        {
            for(int m = 0; m < 20; m++)
            {
                if(aireDeJeu[i][m] == 1)
                {
                    somme = somme + 1;
                    if(somme == 10)
                    {
                        System.out.println("Weshhhhhh!!!!");
                        for(int j =0; j<10; j++)
                        {
                            aireDeJeu[j][15] = 0;
                        }
                    }
                }
            }
        }
    }
 
    public void paint(Graphics g)
    {
        super.paint(g);
        setBackground(Color.WHITE);
        f.paint(g);
 
        // Afficher toutes les figures déjà positionnées
 
        for(int i = 0;i<10;i++)
        {
            for(int j=0;j<20;j++)
            {
                if(aireDeJeu[i][j]==1)
                {
                    g.fillRect(i*20,j*20,20,20);
                    setBackground(Color.BLACK);        
                }
            }
        }
        setBackground(Color.WHITE);        
    }
 
    public void changeOrientationFigure()
    {
        f.changeOrientation();
        repaint();
    }
    public void deplacementFigureGaucheBis()
    {
        f.deplacementFigureGauche();
        repaint();
    }
    public void deplacementFigureDroiteBis()
    {
        f.deplacementFigureDroite();
        repaint();
    }
}

la classe FIGURE:

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
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
 
/**
 * Décrivez votre classe Figure ici.
 * 
 * @author (votre nom) 
 * @version (un numéro de version ou une date)
 */
public class Figure extends JComponent implements Runnable
{
    int x,y;//coord
    int largeur;
    int[] largeurs;
    int orientation;//orientation : 0,1,2 ou 3
    int[][][] figure;//tableau d'entiers, orientation puis 4 cases sur 4 cases
    private Thread figureTombe;   
 
    int [][] aireDeJeu;
    public Figure()
    {
        figureTombe = new Thread(this);
        x = 3;
        y = 0;
        orientation = 1;
    }
 
    public Figure(int [][] aireDeJeu)
    {
        this.aireDeJeu = aireDeJeu;
    }
 
    public void tombe()
    {
        figureTombe.start();
    }
 
    public void paint(Graphics g)
    { 
    }
 
    public void changeOrientation()
    {
        while(figureTombe.isAlive())
        {
            orientation = (orientation+1)%4;
            largeur = largeurs[orientation];
 
            if(x == 10 - this.largeur+1)
            {
                x = x - 1;
            }
        }
    }
 
    public void deplacementFigureGauche()
    {   
        if(x > 0)// tant que x est positive
        {
            x = x - 1;
        }
    }
    public void deplacementFigureDroite()
    {
        if(x < 10-this.largeur)// tant que x est plus petit que 10
        {
            x = x + 1;
        }
    }
 
    /*
     * fait descendre la figure
     */
    public void run()
    {
        while(figureTombe.isAlive())
        {
            try
            {
                Thread.sleep(500);
                getParent().repaint();
//                         figureTombe.interrupt();
//                         figureTombe = null;
            }catch(InterruptedException ie){}
            y++;
        }
    }
 
}

la classe T (une pièce du tétris - la seule pour le moment)

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
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
 
public class T extends Figure
{
    public T() 
    {
        super();
        int[][][] _figure = {
            {{1,0,0,0},{1,1,0,0},{1,0,0,0},{0,0,0,0}},
            {{0,1,0,0},{1,1,1,0},{0,0,0,0},{0,0,0,0}},
            {{0,1,0,0},{1,1,0,0},{0,1,0,0},{0,0,0,0}},
            {{1,1,1,0},{0,1,0,0},{0,0,0,0},{0,0,0,0}} };
        this.figure = _figure;
        int[]l = {3,2,3,2};
        largeur = l[orientation];
        largeurs = l;
        this.tombe();
    }
 
    public void paint(Graphics g)
    {
        g.setColor(Color.BLACK);
        for(int i=0;i<4;i++)
        for(int j=0;j<4;j++)
        {
            if(figure[orientation][i][j]==0)
            {   
                g.setColor(Color.WHITE);
                g.fillRect((x+i)*20,(y+j)*20,20,20);                
                g.setColor(Color.BLACK);
                repaint();
            }
            else
            {
                g.fillRect((x+i)*20,(y+j)*20,20,20);
                repaint();
            }
        }
 
    }    
}

Merci beaucoup

[Ivelios]

Bonsoir,
quelque petite chose sur l'architecture de votre projet

Code :

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

1
2
3
f = new T();
this.add(f);
t = new Figure(aireDeJeu);

L'aire de jeu est une figure et T est une figure aussi => Pas normal.
L'aire dejeu n'a pas à être une figure.

Ici c'est la figure qui possède le thread => Pas normal non plus.
C'est la classe mère qui doit posséder le thread.

Je vous propose le plan suivant pour implémenter votre tétris, vous évitant ainsi de futur problème.

Une classe figure qui possède :
int[][] position.

Une classe mère qui possède :
Un thread, la pièce (figure) courante, int[][] aire de jeux

Dans le thread, on décale la figure de +1 dans les Y (comme actuellement) toute les 500ms et on repaint
La classe mère gère aussi les Evenement clavier et modifie la figure en conséquence sur l'axe des X + repaint.
Dans le thread, avant de décaler en Y, on vérifie que la pièce puisse bien descendre. Pour cela on récupère sa position et on compare avec l'aire de jeux.

Enfin, si la pièce est en bas, on modifie la pièce courante de la classe mère par une nouvelle pièce. (l'ancienne pièce peut être sauvegardé dans une liste par exemple).

En espérant avoir pu vous aider