Discussion :

[BaptisteTienko]

Bonjour,

Je suis en ce moment sur un jeu d'echecs et j'aimerais trouver un moyen plus efficace que celui que j'utilise en ce moment pour que , lors d'un dragged d'une piece d'echecs (image) avec la sourie, celle-ci suive la sourie jusqu'a ce que l'evenement MouseReleased survienne.

Pour le moment, j'utilise les coordonnées dans la méthode Mouseclick pour récupérer l'image de la piece, puis, dans la methode MouseDragged, j'appel la methode repaint() , qui affiche le plateau de Jeu (IMAGE) , toutes les pieces de l'echiquier présentes (IMAGES) puis la piece (IMAGE) à la position précisé par MouseDragged.
Ainsi j'ai bien ce que je veux , mais avec cette méthode, l'image de la piece suit la sourie avec un grand temps de latence (car je fais des calculs pour les pieces et le plateau).

N'y a t'il pas une méthode moins triviale afin que l'image suive la sourie, sans laisser de trace sur le plateau biensûr, mais ce instantanément ou presque?

[looclooc]

Bonjour BaptisteTienko,

J'ai déja eu a faire ce genre de chose plusieurs fois, et je crois avoir la réponse a ton probleme.

tu affiche tes images dans des ImageIcon que tu associe a des JLabel ou des JPanel par exemple, c'est bien ça? ou alors tu dessine en Graphics toute ta table et tes images de pions?

Une fois que tu m'araus donné cette indication, je pourrait être précis dans la réponse

[BaptisteTienko]

Mon code sera plus explicite je pense. Voici mon objet PanelEchiquier que j'ajoute indépendamment à un JPanel du JFrame de jeu:

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
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
 
private class PanelEchiquier extends JPanel implements MouseListener, MouseMotionListener{
 
        private Point mousePressed,mouseReleased,mouseDragged;
        private Image ImgPieceDragged;
 
        PanelEchiquier(){
            super();
            this.setPreferredSize(DIMENSION_PLATE);
            this.setBackground(Color.white);
            this.setBorder(BorderFactory.createMatteBorder(1, 1, 1, 0, ColorBorder));
            this.addMouseListener(this);  
            this.addMouseMotionListener(this);
            mousePressed = new Point();
            mouseReleased = new Point();
            mouseDragged = new Point();
            ImgPieceDragged = null;
        }
 
        @Override
        public void paintComponent(Graphics g){
            paintPlateGame(g);
            paintPiecesChess(g);
            paintImageIconPieceDragged(g);
        }
        private void paintPlateGame(Graphics g){
            String CibleImgPlate;
            if("blanc".equals(ConfigPlayer.color)){
                CibleImgPlate = staticInclude.CIBLE_IMG_PLATE_WHITE_BASIC;
            }else{
                CibleImgPlate = staticInclude.CIBLE_IMG_PLATE_BLACK_BASIC;
            }
            try {
                g.drawImage(ImageIO.read(new File(CibleImgPlate)),
                            0,
                            0,
                            DIMENSION_PLATE.width, 
                            DIMENSION_PLATE.height,
                            this);
            } catch (IOException ex) {
                JOptionPane.showMessageDialog(null,"Impossible de charger l'image " + staticInclude.CIBLE_IMG_PLATE_WHITE_BASIC
                                                    + ".\n Verifiez que vous avez bien installé SNChessPlayer.","Fichier manquant",2);
            }
        }
        private void paintPiecesChess(Graphics g){
            if("blanc".equals(ConfigPlayer.color)){
                for(int i=0;i<8;i++){
                    for(int j=0;j<8;j++){
                        ImageIcon PieceImage = MainPlateChess.Plate[i][j].getImageIcon();
                        if(PieceImage!=null)
                            g.drawImage(PieceImage.getImage(),
                                        DIMENSION_PIECES.width * j + 20,
                                        DIMENSION_PLATE.height - ((1 + i) * DIMENSION_PIECES.height) - 20,
                                        DIMENSION_PIECES.height, 
                                        DIMENSION_PIECES.width,
                                        this);
                    }
                }
            }else{
                for(int i=0;i<8;i++){
                    for(int j=0;j<8;j++){
                        ImageIcon PieceImage = MainPlateChess.Plate[i][j].getImageIcon();
                        if(PieceImage!=null)
                            g.drawImage(PieceImage.getImage(),
                                        DIMENSION_PLATE.width - DIMENSION_PIECES.width * (j+1),
                                        DIMENSION_PIECES.height * i,
                                        DIMENSION_PIECES.height, 
                                        DIMENSION_PIECES.width,
                                        this);
                    }
                } 
            }   
        }
        private void paintImageIconPieceDragged(Graphics g){
            if(ImgPieceDragged==null)
                return;
            g.drawImage(
                    ImgPieceDragged,
                    mouseDragged.x - DIMENSION_PIECES.width / 2,
                    mouseDragged.y - DIMENSION_PIECES.height / 2,
                    DIMENSION_PIECES.height, 
                    DIMENSION_PIECES.width,
                    this);
 
        }
        public void mouseClicked(MouseEvent e) {               
         }
        public void mouseReleased(MouseEvent e) {
            if("blanc".equals(ConfigPlayer.color)){
                mouseReleased.x = (( (e.getX() - 20) / DIMENSION_PIECES.width ));
                mouseReleased.y   = (7-(e.getY() / DIMENSION_PIECES.height));
 
            }else{
                mouseReleased.x = (7-( ( e.getX()-20) / (DIMENSION_PIECES.width) )) ;
                mouseReleased.y   = ((e.getY() / DIMENSION_PIECES.height));
            }
            movePiece_withinClick();
        }
        public void mousePressed(MouseEvent e) {
             if("blanc".equals(ConfigPlayer.color)){
                mousePressed.x = (( (e.getX() - 20) / DIMENSION_PIECES.width ));
                mousePressed.y   = (7-(e.getY() / DIMENSION_PIECES.height));
 
            }else{
                mousePressed.x = (7-( ( e.getX()-20) / (DIMENSION_PIECES.width) )) ;
                mousePressed.y   = ((e.getY() / DIMENSION_PIECES.height));
            }
            if(mousePressed.x>=0 && mousePressed.x<=7){
                if( mousePressed.y>=0 && mousePressed.y<= 7){
                    ImgPieceDragged = MainPlateChess.Plate[mousePressed.y][mousePressed.x].getImageIcon().getImage();
                }
            }
        }
        public void mouseEntered(MouseEvent e) {
            setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        }
        public void mouseExited(MouseEvent e) {
            setCursor(Cursor.getDefaultCursor());
        }
        public void mouseDragged(MouseEvent e) {
            mouseDragged.x = e.getX();
            mouseDragged.y = e.getY();
            repaint();
        }
        public void mouseMoved(MouseEvent e) {
 
        }
        private void movePiece_withinClick(){
            if(mousePressed.x>=0 && mousePressed.x<=7){
                if( mousePressed.y>=0 && mousePressed.y<= 7){
                    if(mouseReleased.x >= 0 && mouseReleased.x <=7){ 
                        if(mouseReleased.y >=0 && mouseReleased.y <=7){
                            ChessStrategy.movePiece_byUser(new Point(mousePressed.y, mousePressed.x),new Point(mouseReleased.y , mouseReleased.x));
                            repaint();   
                        }
                    }
                }
            }
            ImgPieceDragged = null;
        }
 
    }

Merci de ton aide

[BaptisteTienko]

Je viens de lire par un modo ceci:

il ne faut jamais faire de traitement lourd dans cette méthode (PaintComponent()), donc ne jamais y charger une image à partir d'un disque. Tu dois le faire une fois pour toute dans le constructeur.

Alors je vais déjà essayer de suivre une règle d'or d'un expert et je te tien au courant.
(Je veux comme même connaître une méthode plus avancé pour mon problème! )

[BaptisteTienko]

Je dois dire que le différence est flagrante! Je charge mes images au démarrage de l'application et c'est pas mal du tout!

Mais ma curiosité est toujours assoifée, j'attend l'aide que tu m'a promis avec impatience!

[looclooc]

Bonjour BaptisteTienko,
Je viens de lire vite fait le code, je le relirai plus en detail tout a l'heure (je suis au boulot), mail il y a quelques petites remarques et questions que j'aimerai te poser:

- Tu considere que ton echiquier, ainsi que toutes tes pieces sont des images, que tu redessine a chaque fois qu'il y a un mouvement ou une interraction? en gros, la methode "paintComponent" (ou "paint") redessine a chaque fois le nouvel état? Pourquoi tu ne creerais pas plutot une Classe Echiquier (JPanel) dans laquelle tu charge une fois pour toute l'image de ton echiquier, et aussi une Classe "Piece" (JPanel aussi, ou meme JLabel), dans laquelle tu charge aussi les images des pieces associée une fois pour toute, et dans laquelle tu spécifie des attribut (type de piece: pion, tour, ...., couleur: blanc, nouir, ....). tu tireras plus d'avantage de la POO de cette façon, et ça te facilitera les manipulations et les deplacements. Sans oublier que tu n'aura plus besoin de faire appel a des "repaint()" puisque un "setLocation(x,y)" d'une de tes piece (qui serait un JPanel ou JLabel) ferait tout ce qu'il faut?

Comme je te l'ai dit, je vais regarder ton code plus en detail tout a l'heure, mais si ça t'interesse, je pourrait te faire un nouveau code qui ferait ce que tu veux, et tu jugera si ça t'interesse ou pas?