Discussion :

[relax-man]

Bonjour à tous,
je suis dans un groupe de 5 personnes et nous devons programmer un jeu du taquin. Je dois m'occuper de l'interface graphique du jeu.
Mon souci est de savoir quelle va être la nature des cases que l'on va déplacer dans le jeu? Est ce que l'on peut partir du principe que ce sont des JButtons qui vont se déplacer sur le plateau de jeu? Est il possible de déplacer des JButtons dans notre JFrame? Voila, c'est un peu compliqué au démarrage, je sais pas par ou commencer

Merci beaucoup pour votre aide!

[-Dici-]

Salut,

Ayant moi-même programmé un taquin cette année j'ai du code fonctionnel tout cuit. Bien sûr, ça ne serait pas drôle si je te donnais tout et après tout, si ça se trouve vous ferez mieux que moi si vous vous y mettez ! Je vais donc seulement te donner la structure (uniquement des classes graphiques) :

- une classe ImagePane toute simple qui hérite de JPanel et contient une BufferedImage qu'elle affiche en overridant paintComponent

- une classe GraphicTaquin qui hérite de JFrame et contient un ImagePane, un Taquin, une matrice de java.awt.Point (Point[][]), et bien d'autres attributs aux utilités diverses. Elle manipule directement la BufferedImage encapsulée par son ImagePane.

- une classe TaquinGUI qui hérite de JFrame et sert à lancer le jeu et permet de choisir l'image à utiliser via un JFileChooser, choisir la taille du jeu etc. Cette fenêtre est unique et on peut ouvrir depuis elle plusieurs GraphicTaquin (qui constitue le vrai jeu).

La classe la plus importante est GraphicTaquin, donc je te la détaille un peu avec un genre d'interface :

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
 
/**Permute les pixels de coordonnees respectives p1 et p2.
  * @param p1 coordonnees de la premiere case
  * @param p2 coordonnees de la deuxieme case
  */
public void permute(Point p1, Point p2);
 
/**Permute les blocs de coordonnees respectives p1 et p2.
  * @param p1 coordonnees du premier bloc
  * @param p2 coordonnees du deuxieme bloc
  */
public void permute(Point p1, Point p2);
 
/**Noircir le bloc de coordonnees de bloc p.
  * @param p coordonnees du bloc
  */
public void holeBlock(Point p);
 
/**
  *  Conversion des coordonnees pixelliques de la souris en coordonnees de bloc. 
  *  @return coordonnées de bloc du bloc contenant le pixel pointé par la souris. Si le jeu est de taille n, les coordonnées retournées seront dans
  *               [0,n-1] x [0,n-1]
  */
private Point mouseToBlock();

Quand je parle de blocs, il s'agit de la matrice Point[][] que j'ai déjà évoquée. Cette matrice est calculée lors de la construction de la fenêtre GraphicTaquin en fonction de :

- la taille n du jeu
- la largeur width de l'image
- la hauteur height de l'image

Attention au cas où height ou width ne sont pas divisibles par n ! Tu peux ne pas le traiter mais dans ce cas soit tu auras des blocs de même taille et les bords ne bougeront pas, soit tu devras traiter les blocs des extrêmes différemment (ils auront une taille différente). Personnellement je ne l'avais pas traité car dans ce projet je m'étais concentré sur l'algo de résolution.

Cette matrice, que j'ai nommée blocks, est telle que blocks[i][j] contient les coordonnées pixelliques (dans la BufferedImage) du coin gauche supérieur du bloc (i,j). Ainsi, à l'aide de blockWidth et blockHeight (également calculés dans le constructeur) on sait délimiter le bloc (i,j). Au final tu ne feras que permuter des blocs dans ta BufferedImage, il n'y a donc ni bouton ni rien du tout, juste un JPanel et une image dedans !

[relax-man]

Merci beaucoup pour l'aide et le temps passé. Je vais m'y coller et je reviendrai en cas de pépin!