Problème pour bloquer les pièces d'un Tétris

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:

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:

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:

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