Jeu d'echec en Java ...article 3

Le constructeur définie lors du précédent tutoriel , nous permet de générer la grille suivante , sans les icones bien sûr , je vais vous détailler sur ce tuto les deux fonctions permettant la génération de ces icones sur cette grille ...

Avant de passer aux fonctions d'initialisation , je reviens un peu en détail au précédent constructeur , en précisant que notre classe DisplayingTable herite de la classe mere Jframe , et qu'aussitôt une instance généré , son constructeur se charge de récupéré une référence vers le Container de cette page et d'y ajouter a la fin notre Jpanel surchargé d'éléments de jeu,

l'allocation du GridBaglayout s'est faite alors sur le Jpanel tables pour que table puisse être ajouter au Container.

Revenons maintenant à l'initialisation de nos éléments de jeu , deux fonctions ont été nécessaire à cela :

la classe initialisation , qui se charge d'importer une icône définissant chaque élément de jeu , en spécifiant comme paramètre , le chemin vers l'icone en String , et les coordonnées de l'élément auxquels elle devra être affecter .

public void initialisation(String url_file,int i,int j)

{

JLabel label=new JLabel();

label.setOpaque(true);

label.setIcon(new ImageIcon(url_file));

label.setBackground(colors[i][j]);

label.setPreferredSize(new Dimension(50,50));

label.addMouseListener(listener);

table.remove(labes[i][j]);

table.add(label,TransformerTool.GBTransformer(GBC,i,j,1,1));

}

tachez pour l'instant de ne pas trop vous focaliser sur les lignes de commandes permettant d'ajouter des listener à nos objets . Cette fonction d'initialisation , créer à chaque appel un nouvel objet lui alloue comme couleurs , la couleur de la case correspondante , et la on remarque l'utilité de la création d'un tableau de couleurs ,cette mémorisation s'avère donc être utile :) !

on supprimera par la suite l'élément visé à travers les coordonnées donnée en paramètres , cela bien sur afin de le remplacer par le nouvel élément instancié.

Cette fonction à été surtout crée pour être soliciter à travers plusieurs appels, par une fonction appelons la mere ^^ , qui initialisera tout les éléments du jeu :

public void ElementsInitialisation()

{

for(int i=0;i<8;i++)

{

this.initialisation("pion_blanc.gif",i,1);

}

for(int i=0;i<8;i++)

{

this.initialisation("pion_noir.gif",i,6);

}

this.initialisation("tour_blanche.gif",0,0);

this.initialisation("tour_blanche.gif",7,0);

this.initialisation("fou_blanc.gif",2,0);

this.initialisation("fou_blanc.gif",5,0);

this.initialisation("chevalier_blanc.gif",1,0);

this.initialisation("chevalier_blanc.gif",6,0);

this.initialisation("reine_blanche.gif",4,0);

this.initialisation("roi_blanc.gif",3,0);

this.initialisation("tour_noir.gif",0,7);

this.initialisation("tour_noir.gif",7,7);

this.initialisation("fou_noir.gif",2,7);

this.initialisation("fou_noir.gif",5,7);

this.initialisation("chevalier_noir.gif",1,7);

this.initialisation("chevalier_noir.gif",6,7);

this.initialisation("reine_noir.gif",3,7);

this.initialisation("roi_noir.gif",4,7);

}

la fonction ,ElementsInitialisation initialisera à travers plusieurs appels à la précédente fonction tout les éléments de jeu , tachez juste de mettre les bonnes coordonnées et à ne pas vous trompez lors de la spécification du chemin relatifs à chaque icône .

Voilà, pour cette toute première partie graphique, on développera dans les prochains tuto, l'utilisation de nos Listners pour en quelques sorte dynamiser ce graphisme... vous aurez aussi bien affaire aux classes du package Bakend qu'a ceux de EventHandlers … :p

Jeu d'echec en Java ... (Article 2)

Hola los amigos ^^ , je vous rassure je me sent très bien aucune séquelle mental pour l'instant , que du plaisir c'est juste que je me suis mis à l'Espagnol , formation oblige =) ...aller, sans plus tarder

je vais commencer à exposer ce que contient ce fameux package graphique. Et c'est sans vous dire que nous allons traiter des tas de nouveaux concepts...

Avant de construire n'importe quel chose , nous aurons bien besoin d'outil , fini les temps des pharaons ou on soulevais des pierres de plusieurs centaine de Kilo en utilisant des moyens dérisoires,

ma table de jeu aura bien besoin d'outils permettant une intégration facile des éléments de jeu,

Avant de parler d’outils, on va commencer tout d'abord par expliquer en quoi consiste cette grille de jeu, une grille assez simple, contenant un Jpanel auquel nous avons définie un GridBagLayout,

je tiens à signaler qu'avant d'appliquer un GridBagLayout , j'ai fait quelques tests non concluant en utilisant un GridLayout , conclusion tiré , le GridBagLayout offre plus de flexibilité quand au positionnement et à la récupération de ses éléments .

Pour ajouter un élément à un GridBagLayout nous aurons forcement besoin d'un GridBagConstraints, qui nous permet de définir les contraintes relatifs à chaque élément (coordonnée sur la grille : gridx,gridy et nombre de case concernée :gridwidth,gridheight)

et c'est la que la définition d'un premier outil graphique s'est imposé , nous auront tellement d'éléments à gérer qu'il sera totalement bourrin le fait de modifier les paramètres de ces contraintes chaque ajout, ma Class DisplayingTools contient donc une fonction , GridBagTransformer qui prend comme paramètre mon GridBagConstraints , aussi bien que les valeurs des éléments à assigner à chacun de ses paramètres , se charge ensuite de les modifier et de retourner l'objet prêt à être utiliser lors du prochain ajout :

public GridBagConstraints GBTransformer(GridBagConstraints GridBagCInput,int x,int y,int px, int py)

{

GridBagCInput.gridx=x;

GridBagCInput.gridy=y;

GridBagCInput.gridwidth=px;

GridBagCInput.gridheight=py;

return GridBagCInput;

}

Enfin, et pour illustrer l'utilisation de cet outil , je vais devoir passer à la classe DisplayingTable , sur laquelle la grille aussi bien que tout les éléments de jeu sont instanciée et ajouté.

Chaque case de ma grille aura forcement besoin d'un élément définissant aussi bien sa couleur qu'éventuellement l'icone (pion, tour, cheval , reine ...etc. ) désignant l'élément présent. Nous opterons alors pour des Jlabel , ce qui nous évitera d'avoir a chaque fois à dessiner un rectangle et d'y ajouter une icône ,

Nous aurons donc à initialiser les éléments suivant :

private JLabel [][] labes=new JLabel[8][8];

private JPanel table=new JPanel();

private Color [][] colors=new Color[8][8];

private GridBagConstraints GBC=new GridBagConstraints();

private DisplayingTools TransformerTool=new DisplayingTools();

le premier tableau labes contient tout les éléments à ajouter à chaque case de notre Jpanel,

notre Jpanel a été initialisé juste en dessous,

le tableau Colors, nous permet d'avoir en mémorisation la couleur de chaque case. Enfin et en dernier , nous avons définie nos deux éléments GridBagConstraints GBC et TransformerTool qui vont nous aider en quelque sorte à ajouter nos éléments d'une manière assez soft .

Notre constructeur, DisplayingTable se chargera donc d'initialiser chaque élément , de modifier notre GBC à travers l'outils définie précédemment pour au final l'ajouter à notre Jpanel table :

public DisplayingTable()

{

Container container=getContentPane();

container.setLayout(null);

table.setLayout(new GridBagLayout());

boolean commute=false;

for(int i=0;i<8;i++)

{

for(int j=0;j<8;j++)

{

if(i%2==0)

{

if(commute==true)

{

labes[i][j]=new JLabel();

labes[i][j].setOpaque(true);

labes[i][j].setBackground(Color.green);

colors[i][j]=Color.green;

labes[i][j].setPreferredSize(new Dimension(50,50));

table.add(labes[i][j],TransformerTool.GBTransformer(GBC,i,j,1,1));

commute=false;

}

else if (commute==false)

{

labes[i][j]=new JLabel();

labes[i][j].setOpaque(true);

labes[i][j].setBackground(Color.yellow);

colors[i][j]=Color.yellow;

labes[i][j].setPreferredSize(new Dimension(50,50));

table.add(labes[i][j],TransformerTool.GBTransformer(GBC,i,j,1,1));

commute=true;

}

}

else {

if(commute==false)

{

labes[i][j]=new JLabel();

labes[i][j].setOpaque(true);

labes[i][j].setBackground(Color.green);

colors[i][j]=Color.green;

labes[i][j].setPreferredSize(new Dimension(50,50));

table.add(labes[i][j],TransformerTool.GBTransformer(GBC,i,j,1,1));

commute=true;

}

else if(commute=true)

{

labes[i][j]=new JLabel();

labes[i][j].setOpaque(true);

labes[i][j].setBackground(Color.yellow);

colors[i][j]=Color.yellow;

labes[i][j].setPreferredSize(new Dimension(50,50));

table.add(labes[i][j],TransformerTool.GBTransformer(GBC,i,j,1,1));

commute=false;

}

}

}

}

table.setBounds(0,0,500,500);

container.add(table);

}

le raisonnement est assez logique , on initialise à chaque fois un nouveau Jlabel, on lui assigne une couleur , en faisant en sorte à travers une variable booléenne commute , de générer un effet de commutation ,donnant ainsi à la grille la distribution exacte en jeune et vert :

premiere ligne : jaune – vert -jaune – vert ... ect

deuxieme ligne : vert- jaune -vert- jaune ... ect

pour à la fin ajouter chaque element à la table .

Je vous laisse un peu de temps pour vous imprégner de tout ça, de toute façon j'y reviendrai sur mon prochain tuto... ;)