Salut,

Je pense que tu dois juste créer une fonction qui représente la logique de ton programme (l'algorithme que tu suivras), et puis tu l'appelle dans la méthode actionPerformed de ton listener, je ne pense pas que c'est si compliqué.

Cette méthode doit changer les images de tes boutons selon tes conditions, c'est tout.

Bonne chance.

Hello,

Ben en fait pour ca j'ai envisagé deux facons de voir les choses, peut être y en a t'il plus.....

La première :
Tu définies un attributà ta classe Frame, tableau matrice de JButton de la facon suivante....

JButton[][] mButtons = new JButton[5][5];

public void actionPerformed(ActionEvent e) {
 for (int i = 0; i < mButtons.length; i++) {
  for (int j = 0; j < mButton[i].length j++) {
    if (((JButton)e.getSource()).equals(mButtons[i][j])) {
       //Alors la tu as récupéré la position dans le tableau du boutton cliqué, il te suffit de changer la couleur des pions que tu veux par rapport a celui ci.
    }
  }
 }
}

Pour la seconde, la c'est un peu plus complexe, d'ailleurs j'insiste bien sur le fait que tt est dans l'ancien topic, voir mon dernier post :)

Mais sinon pour l'explication, chaque boutton va avoir des attributs spécifiques qui vont etre sa couleur, et une liste des boutons qui vont changer de couleur en même temp qu'il sera cliqué. Cette liste de bouttons sera chargée au moment où tu initialiseras ta fenetre.
Pour faire ca en java, un petit peu d'héritage :

class ReversoPion extends JButton {
 private List<ReversoPion> mReversoPionsVoisins;
 // enumeration pour indiquer la couleur du pion valeur {fonce, clair}
 private CouleurReversoPioin mCouleurReversoPion;
}

La méthode actionPerformed devient ceci "extrait de l'autre topic" :

public void actionPerformed(ActionEvent pE) { 
                changeReversoPionCouleur(); 
                changeReversoPionsVoisinsCouleur(); 
}

avec les méthodes biens senties :

public void changeReversoPionCouleur() { 
        if (mCouleurReversoPion == CouleurReversoPion.clair) { 
            mCouleurReversoPion = CouleurReversoPion.fonce; 
            setIcon(sImageIconPionFonce); 
        } else if (mCouleurReversoPion == CouleurReversoPion.fonce) { 
            mCouleurReversoPion = CouleurReversoPion.clair; 
            setIcon(sImageIconPionClair); 
        } 
    } 
    
    public void changeReversoPionsVoisinsCouleur() { 
        for (ReversoPion vReversoPionTmp : mReversoPionsVoisins) { 
            vReversoPionTmp.changeReversoPionCouleur(); 
        } 
    } 

C'est quand même moins chargé :) .

Bonne chance,
Niroken

Hello,

Pour la grosse tête je blaguais rassures toi :) , bon sinon pour le reste, ca se complique un peu.... mais le mot d'ordre pour cette nouvelle année est..code propre, pas de bazard :)

Donc je te propose une implémentation que tu retrouveras ci dessous, voici comment j'ai vu les choses... je précise avant tte chose que tt ce que j'ai fait peut être sujet à critiques et/ou améliorations.

Le fait que tu veuilles pouvoir choisir le comportement de tes boutons, par "mode", si je puis dire à imposer de découper l'interface en deux parties... une partie qui contient les bouttons reverso, et une autre qui contient le "mode controller" avec un bouton par mode.

J'ai revu un peu mon implémentation pour l'adapter à ton nouveau besoin, parceque ce que j'avais proposé avant ne collait plus tt a fait.

Dans les changements :

Creation de deux nouveaux Panels, un qui contient le tableau de ReversoPions, lautre qui contient les bouttons selecteur de mode.

Les ReversoPions ne contiennent plus la liste de leurs voisins, mais leur position direct dans le tableau, c est le panel qui contient les bouttons qui s'occupera de changer la couleur du boutton cliqué et de ses voisins.

J'ai crée une interface ReversoPionClickedBehaviour avec une seule méthode, c'est l'implémentation de cette interface qui déterminera quel comportement le panel doit adopter quand on clique sur un de ses bouttons.

Code de la fenetre :

package graphic; 

import graphic.container.ReversoPionsBehaviourController;
import graphic.container.ReversoPionsPanel;

import java.awt.Dimension; 
import java.awt.FlowLayout;

import javax.swing.JFrame; 

public class ReversoFrame extends JFrame { 

    private static final long serialVersionUID = 1L; 
    
    private ReversoPionsPanel mReversoPionsPanel;
    private ReversoPionsBehaviourController mReversoPionsBehaviourController;
    
    public ReversoFrame() { 
    	setTitle("Reverso"); 
    	setSize(new Dimension(400, 250));
    	setLayout(new FlowLayout());
    	
    	mReversoPionsPanel = new ReversoPionsPanel();
    	mReversoPionsBehaviourController = new ReversoPionsBehaviourController(mReversoPionsPanel);
    	
    	add(mReversoPionsPanel);
    	add(mReversoPionsBehaviourController);
    	
    	setVisible(true); 
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 
    } 

} 

Code du panel conteneur de ReversoPion :

package graphic.container;

import graphic.component.ReversoPion;

import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JPanel;

import commun.CouleurReversoPion;
import commun.IReversoPionClickedBehaviour;

public class ReversoPionsPanel extends JPanel {
	
	private static final long serialVersionUID = 1L;
	public static final int sReversoGridHeight = 10; 
    public static final int sReversoGridWidth = 10;
	
    private IReversoPionClickedBehaviour  mReversoPionClickedNormalBehaviour = new IReversoPionClickedBehaviour () {
    	
		public void doReversoPionAction(ReversoPion pReversoPionClicked) {
			int vClickedAbs = pReversoPionClicked.getPositionInArray().x;
			int vClickedOrd = pReversoPionClicked.getPositionInArray().y;
			
			changeReversoPionAndVoisinsCouleur(mReversoPions[vClickedAbs][vClickedOrd]);
		}
		
	};
	
	private IReversoPionClickedBehaviour  mReversoPionClickedVerticalBehaviour = new IReversoPionClickedBehaviour () {
		
		public void doReversoPionAction(ReversoPion pReversoPionClicked) {
			int vClickedAbs = pReversoPionClicked.getPositionInArray().x;
			int vClickedOrd = pReversoPionClicked.getPositionInArray().y;
			
			changeReversoPionAndVoisinsCouleur(mReversoPions[vClickedAbs][sReversoGridWidth - 1 - vClickedOrd]);
		}
		
	};
	
	private IReversoPionClickedBehaviour  mReversoPionClickedHorizontalBehaviour = new IReversoPionClickedBehaviour () {
		
		public void doReversoPionAction(ReversoPion pReversoPionClicked) {
			int vClickedAbs = pReversoPionClicked.getPositionInArray().x;
			int vClickedOrd = pReversoPionClicked.getPositionInArray().y;
			
			changeReversoPionAndVoisinsCouleur(mReversoPions[sReversoGridHeight - 1 - vClickedAbs][vClickedOrd]);
		}
		
	};
	
	private IReversoPionClickedBehaviour  mReversoPionClickedDiagonaleHGBDBehaviour = new IReversoPionClickedBehaviour () {
		
		public void doReversoPionAction(ReversoPion pReversoPionClicked) {
			int vClickedAbs = pReversoPionClicked.getPositionInArray().x;
			int vClickedOrd = pReversoPionClicked.getPositionInArray().y;
			
			changeReversoPionAndVoisinsCouleur(mReversoPions[vClickedOrd][vClickedAbs]);
		}
		
	};
	
	private IReversoPionClickedBehaviour  mReversoPionClickedDiagonaleHDBGBehaviour = new IReversoPionClickedBehaviour () {
		
		public void doReversoPionAction(ReversoPion pReversoPionClicked) {
			int vClickedAbs = pReversoPionClicked.getPositionInArray().x;
			int vClickedOrd = pReversoPionClicked.getPositionInArray().y;
			
			changeReversoPionAndVoisinsCouleur(mReversoPions[sReversoGridWidth - 1 - vClickedOrd][sReversoGridHeight - 1 - vClickedAbs]);
		}
		
	};
    
    private IReversoPionClickedBehaviour mCurrentReversoPionClickedBehaviour;
	private ReversoPion[][] mReversoPions;
	
    public ReversoPionsPanel() {
		setLayout(new GridLayout(sReversoGridHeight ,sReversoGridWidth)); 
        setPreferredSize(new Dimension(200, 200)); 
          
        mReversoPions = new ReversoPion[sReversoGridHeight][sReversoGridWidth]; 
        
        // Creation de chaque bouton 
        for (int i = 0; i < sReversoGridHeight; i++) { 
            for (int j = 0 ; j < sReversoGridWidth; j++) { 
            	mReversoPions[i][j] = new ReversoPion(CouleurReversoPion.clair, new Point(i, j)); 
                mReversoPions[i][j].addActionListener(new ActionListener() {

					public void actionPerformed(ActionEvent e) {
						mCurrentReversoPionClickedBehaviour.doReversoPionAction((ReversoPion) e.getSource());
					}
                	
                });
            	add(mReversoPions[i][j]); 
            } 
        } 
                
        setCurrentReversoPionClickedBehaviour(mReversoPionClickedNormalBehaviour);
	}
	
	private static boolean isReversoPionInArrayBounds(int i , int j) { 
        if (i >= 0 && j >= 0 && i < sReversoGridHeight && j < sReversoGridWidth) { 
            return true; 
        } else { 
            return false; 
        } 
    }
	
	private void changeReversoPionAndVoisinsCouleur(ReversoPion pReversoPion) {
		int vClickedAbs = pReversoPion.getPositionInArray().x;
		int vClickedOrd = pReversoPion.getPositionInArray().y;
		
		mReversoPions[vClickedAbs][vClickedOrd].changeReversoPionCouleur();
		
		if (isReversoPionInArrayBounds(vClickedAbs - 1, vClickedOrd)) { 
        	mReversoPions[vClickedAbs - 1][vClickedOrd].changeReversoPionCouleur();
        } 
        
        if (isReversoPionInArrayBounds(vClickedAbs + 1, vClickedOrd)) { 
        	mReversoPions[vClickedAbs + 1][vClickedOrd].changeReversoPionCouleur();
        } 
        
        if (isReversoPionInArrayBounds(vClickedAbs, vClickedOrd - 1)) { 
        	mReversoPions[vClickedAbs][vClickedOrd - 1].changeReversoPionCouleur();
        } 
        
        if (isReversoPionInArrayBounds(vClickedAbs, vClickedOrd + 1)) { 
        	mReversoPions[vClickedAbs][vClickedOrd + 1].changeReversoPionCouleur();
        }
	}
	
	public IReversoPionClickedBehaviour getReversoPionClickedNormalBehaviour() {
		return mReversoPionClickedNormalBehaviour;
	}

	public IReversoPionClickedBehaviour getReversoPionClickedVerticalBehaviour() {
		return mReversoPionClickedVerticalBehaviour;
	}

	public IReversoPionClickedBehaviour getReversoPionClickedHorizontalBehaviour() {
		return mReversoPionClickedHorizontalBehaviour;
	}

	public IReversoPionClickedBehaviour getReversoPionClickedDiagonaleHGBDBehaviour() {
		return mReversoPionClickedDiagonaleHGBDBehaviour;
	}

	public IReversoPionClickedBehaviour getReversoPionClickedDiagonaleHDBGBehaviour() {
		return mReversoPionClickedDiagonaleHDBGBehaviour;
	}

	public void setCurrentReversoPionClickedBehaviour(IReversoPionClickedBehaviour pCurrentPionClickedBehaviour) {
		mCurrentReversoPionClickedBehaviour = pCurrentPionClickedBehaviour;
	}
			
}

Code de panel selecteur de modes :

package graphic.container;

import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JPanel;

public class ReversoPionsBehaviourController extends JPanel {
	
	private static final long serialVersionUID = 1L;
	
	private JButton mButtonBehaviourNormal;
	private JCheckBox mCheckBoxBehaviourNormal;
	
	private JButton mButtonBehaviourVerticalChange;
	private JCheckBox mCheckBoxBehaviourVerticalChange;
	
	private JButton mButtonBehaviourHorizontalChange;
	private JCheckBox mCheckBoxBehaviourHorizontalChange;
	
	private JButton mButtonBehaviourDiagonaleHGBDChange;
	private JCheckBox mCheckBoxBehaviourDiagonaleHGBDChange;
	
	private JButton mButtonBehaviourDiagonaleHDBGChange;
	private JCheckBox mCheckBoxBehaviourDiagonaleHDBGChange;
	
	private static Dimension sButtonsDimension = new Dimension(120, 20);
	private ReversoPionsPanel mReversoPionsPanel;	
	
	public ReversoPionsBehaviourController(ReversoPionsPanel pReversoPionsPanel) {
		setLayout(new FlowLayout(FlowLayout.LEFT));
		setPreferredSize(new Dimension(160, 200));
		
		mReversoPionsPanel = pReversoPionsPanel;
		
		mButtonBehaviourNormal = new JButton("Normal");
		mButtonBehaviourNormal.setPreferredSize(sButtonsDimension);
		mButtonBehaviourNormal.addActionListener(new ActionListener() {

			public void actionPerformed(ActionEvent e) {
				setAllCheckBoxesValue(false);
				mCheckBoxBehaviourNormal.setSelected(true);
				
				if (mReversoPionsPanel != null) {
					mReversoPionsPanel.setCurrentReversoPionClickedBehaviour(mReversoPionsPanel.getReversoPionClickedNormalBehaviour());
				}
			}
				
		});		
		mCheckBoxBehaviourNormal = new JCheckBox();
		mCheckBoxBehaviourNormal.setEnabled(false);
		mCheckBoxBehaviourNormal.setSelected(true);
				
		mButtonBehaviourVerticalChange = new JButton("Vertical");
		mButtonBehaviourVerticalChange.setPreferredSize(sButtonsDimension);
		mButtonBehaviourVerticalChange.addActionListener(new ActionListener() {

			public void actionPerformed(ActionEvent e) {
				setAllCheckBoxesValue(false);
				mCheckBoxBehaviourVerticalChange.setSelected(true);
				
				if (mReversoPionsPanel != null) {
					mReversoPionsPanel.setCurrentReversoPionClickedBehaviour(mReversoPionsPanel.getReversoPionClickedVerticalBehaviour());
				}
			}
				
		});
		mCheckBoxBehaviourVerticalChange = new JCheckBox();
		mCheckBoxBehaviourVerticalChange.setEnabled(false);
		
		mButtonBehaviourHorizontalChange = new JButton("Horizontal");
		mButtonBehaviourHorizontalChange.setPreferredSize(sButtonsDimension);
		mButtonBehaviourHorizontalChange.addActionListener(new ActionListener() {

			public void actionPerformed(ActionEvent e) {
				setAllCheckBoxesValue(false);
				mCheckBoxBehaviourHorizontalChange.setSelected(true);
				
				if (mReversoPionsPanel != null) {
					mReversoPionsPanel.setCurrentReversoPionClickedBehaviour(mReversoPionsPanel.getReversoPionClickedHorizontalBehaviour());
				}
			}
				
		});	
		mCheckBoxBehaviourHorizontalChange = new JCheckBox();
		mCheckBoxBehaviourHorizontalChange.setEnabled(false);
		
		mButtonBehaviourDiagonaleHGBDChange = new JButton("Diagonale : \\");
		mButtonBehaviourDiagonaleHGBDChange.setPreferredSize(sButtonsDimension);
		mButtonBehaviourDiagonaleHGBDChange.addActionListener(new ActionListener() {

			public void actionPerformed(ActionEvent e) {
				setAllCheckBoxesValue(false);
				mCheckBoxBehaviourDiagonaleHGBDChange.setSelected(true);
				
				if (mReversoPionsPanel != null) {
					mReversoPionsPanel.setCurrentReversoPionClickedBehaviour(mReversoPionsPanel.getReversoPionClickedDiagonaleHGBDBehaviour());
				}
			}
				
		});
		mCheckBoxBehaviourDiagonaleHGBDChange = new JCheckBox();
		mCheckBoxBehaviourDiagonaleHGBDChange.setEnabled(false);
		
		mButtonBehaviourDiagonaleHDBGChange = new JButton("Diagonale : /");
		mButtonBehaviourDiagonaleHDBGChange.setPreferredSize(sButtonsDimension);
		mButtonBehaviourDiagonaleHDBGChange.addActionListener(new ActionListener() {

			public void actionPerformed(ActionEvent e) {
				setAllCheckBoxesValue(false);
				mCheckBoxBehaviourDiagonaleHDBGChange.setSelected(true);
				
				if (mReversoPionsPanel != null) {
					mReversoPionsPanel.setCurrentReversoPionClickedBehaviour(mReversoPionsPanel.getReversoPionClickedDiagonaleHDBGBehaviour());
				}
			}
				
		});	
		mCheckBoxBehaviourDiagonaleHDBGChange = new JCheckBox();
		mCheckBoxBehaviourDiagonaleHDBGChange.setEnabled(false);
		
		disableDiagonaleButtonsIfNotSquareReversoPionsPanel();
		
		add(mButtonBehaviourNormal);
		add(mCheckBoxBehaviourNormal);
		add(mButtonBehaviourVerticalChange);
		add(mCheckBoxBehaviourVerticalChange);
		add(mButtonBehaviourHorizontalChange);
		add(mCheckBoxBehaviourHorizontalChange);
		add(mButtonBehaviourDiagonaleHGBDChange);
		add(mCheckBoxBehaviourDiagonaleHGBDChange);
		add(mButtonBehaviourDiagonaleHDBGChange);
		add(mCheckBoxBehaviourDiagonaleHDBGChange);
		
	}
	
	private void disableDiagonaleButtonsIfNotSquareReversoPionsPanel() {
		if (ReversoPionsPanel.sReversoGridWidth != ReversoPionsPanel.sReversoGridHeight) {
			mButtonBehaviourDiagonaleHGBDChange.setEnabled(false);
			mButtonBehaviourDiagonaleHDBGChange.setEnabled(false);
		}
	}
	
	private void setAllCheckBoxesValue(boolean pValue) {
		mCheckBoxBehaviourNormal.setSelected(pValue);
		mCheckBoxBehaviourVerticalChange.setSelected(pValue);
		mCheckBoxBehaviourHorizontalChange.setSelected(pValue);
		mCheckBoxBehaviourDiagonaleHGBDChange.setSelected(pValue);
		mCheckBoxBehaviourDiagonaleHDBGChange.setSelected(pValue);
	}
	
}

Code des ReversoPions :

package graphic.component; 

import java.awt.Dimension; 
import java.awt.Point;

import javax.swing.ImageIcon; 
import javax.swing.JButton; 

import commun.CouleurReversoPion; 

public class ReversoPion extends JButton { 

    private static final long serialVersionUID = 1L; 
    
    private static ImageIcon sImageIconPionClair; 
    private static ImageIcon sImageIconPionFonce; 
    
    static { 
        sImageIconPionClair = new ImageIcon("b1.gif"); 
        sImageIconPionFonce = new ImageIcon("b2.gif"); 
    } 
    
    private CouleurReversoPion mCouleurReversoPion;
    private Point mPositionInArray;
    
    public ReversoPion(CouleurReversoPion pCouleurReversoPion, Point pPositionInArray) { 
    	setPreferredSize(new Dimension(20, 20));
    	mCouleurReversoPion = pCouleurReversoPion;
        mPositionInArray = pPositionInArray;
        
        if (mCouleurReversoPion == CouleurReversoPion.clair) { 
            setIcon(sImageIconPionClair); 
        } else if (mCouleurReversoPion == CouleurReversoPion.fonce) { 
            setIcon(sImageIconPionFonce); 
        } 
    } 
    
    public void changeReversoPionCouleur() { 
        if (mCouleurReversoPion == CouleurReversoPion.clair) { 
            mCouleurReversoPion = CouleurReversoPion.fonce; 
            setIcon(sImageIconPionFonce); 
        } else if (mCouleurReversoPion == CouleurReversoPion.fonce) { 
            mCouleurReversoPion = CouleurReversoPion.clair; 
            setIcon(sImageIconPionClair); 
        } 
    } 
    
    public Point getPositionInArray() {
		return mPositionInArray;
	}    

} 

Code de l enum :

package commun;

public enum CouleurReversoPion {
	clair, fonce
}

Signature de l interface de comportement :

package commun;

import graphic.component.ReversoPion;

public interface IReversoPionClickedBehaviour {
	
	public void doReversoPionAction(ReversoPion pReversoPionClicked);
	
}

Methode main:

import graphic.ReversoFrame;


public class Program {

	public static void main(String[] args) {
		new ReversoFrame();
	}

}

Si tu as des questions sur mon code, ou sur l'algo en général n'hésites pas.

Bonne chance,
Niroken

Hello Olihya,

J'avoue, je suis bien content que ca t'aie permis d'avancer, c'est l'aide que ca peut apporter qui me motive quand je poste.

Maintenant, je dois dire que je n'ai pas de site perso, c'est à cause de mon point faible, je suis un gros flemmard :) , et puis je n'ai pas encore beaucoup de vécu encore.

Mais ceci dit, l'idée me plait bien. Je te tiendrais au courant quand je passerais à l'action.

Bonne journée,
Niroken