MàJ par récupération sur Clé USB et dans /mnt/hd/Chargement du pc portable

G5a/Puissance4/fr/blankoworld/plateau/AideSaisie.java

@@ -0,0 +1,35 @@
+package fr.blankoworld.plateau;
+
+import java.io.*;
+
+/**
+ * 
+ * @author olivier DOSSMANN
+ *
+ */
+/**
+ * Aide a la recuperation des donnees saisies en console par l'utilisateur
+ */
+public class AideSaisie {
+	/**
+	 * 
+	 * @param prompt
+	 * @return donnees saisies par l'utilisateur
+	 */
+	/**
+	 * Recupere l'entree de console, c'est a dire les donnees saisies par l'utilisateur par la clavier, dans une console
+	 */
+	public String getEntreeUtilisateur(String prompt) {
+		 String inputLine = null;
+		 System.out.print(prompt + "  ");
+		 try {
+			 BufferedReader is = new BufferedReader(new InputStreamReader(System.in));
+			 inputLine = is.readLine();
+			 if (inputLine.length() == 0 )  return null; 
+		 }
+		 catch (IOException e) {
+			 System.out.println("IOException: " + e);
+		 }
+		 return inputLine.toLowerCase();
+	}
+}

G5a/Puissance4/fr/blankoworld/plateau/IhmPuissance4.java

@@ -0,0 +1,480 @@
+package fr.blankoworld.plateau;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.GradientPaint;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.GridLayout;
+import java.awt.RenderingHints;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.border.BevelBorder;
+
+/**
+ * 
+ * @author olivier
+ *
+ */
+/**
+ * Classe permettant d'interfacer le plateau de jeu du Puissance 4
+ */
+public class IhmPuissance4 extends JFrame {
+	
+	private static final long serialVersionUID = 1L;
+	
+	/** Un nouveau plateau de jeu ? */
+	private PlateauPuissance4 p4 = new PlateauPuissance4();
+	
+	/** Un joueur de base que nous utiliserons dans le programme */
+	private Joueurs joueur;
+	
+	/** Nombre de pions dans le jeu */
+	private int comptePion = 0;
+	
+	/** Largeur fenetre */
+	int largeurFenetre = 800;
+	
+	/** Le champ texte de la barre de statut */
+	private JLabel LabelStatut =  new JLabel("Veuillez selectionner une action dans le menu.");
+	/** Le second champ texte de la barre de statut */
+	private JLabel LabelInfos = new JLabel("Aucun Joueur");
+	
+	/** Le paneau centre */
+	JPanel Panneau_Centre;
+	
+	/** Nos degrades de couleur */
+	GradientPaint degradeRouge;
+	GradientPaint degradeJaune;
+	
+	/** Y a t il un gagnant au depart ? */
+	private boolean aucunGagnant = true;
+	
+	/**
+	 * @param args
+	 */
+	/**
+	 * Constructeur de l'IHM
+	 */
+	private IhmPuissance4(){
+		
+		// Creation du menu Jeu
+		JMenu MenuJeu = new JMenu("Jeu");
+		JMenuItem MenuJeu_Nouveau = new JMenuItem("Nouveau");
+		JMenuItem MenuJeu_Quitter = new JMenuItem("Quitter");
+		MenuJeu.add(MenuJeu_Nouveau);
+		MenuJeu.addSeparator();
+		MenuJeu.add(MenuJeu_Quitter);
+		
+		// Creation du menu Aide
+		JMenu MenuAide = new JMenu("Aide");
+		JMenuItem MenuAide_Apropos = new JMenuItem("A propos");
+		MenuAide.add(MenuAide_Apropos);
+		
+		// Creation de la barre de menus
+		JMenuBar MenuPrincipal = new JMenuBar();
+		MenuPrincipal.add(MenuJeu);
+		MenuPrincipal.add(MenuAide);
+		MenuPrincipal.setBorder(new BevelBorder(BevelBorder.RAISED));
+		
+		// Panel au centre
+		Panneau_Centre = new JPanel();
+		Panneau_Centre.setBackground(Color.WHITE);
+		Panneau_Centre.setBorder(new BevelBorder(BevelBorder.RAISED));
+		
+		// Creation de la barre de status
+		JPanel PanneauStatut = new JPanel();
+		PanneauStatut.setLayout(new BorderLayout());
+		PanneauStatut.add(LabelStatut, BorderLayout.WEST);
+		PanneauStatut.add(LabelInfos, BorderLayout.EAST);
+		PanneauStatut.setBorder(new BevelBorder(BevelBorder.RAISED));
+		
+		// Construction de la maquette
+		this.getContentPane().setLayout(new BorderLayout());
+		this.add(PanneauStatut, BorderLayout.SOUTH);
+		this.add(Panneau_Centre, BorderLayout.CENTER);
+		this.add(MenuPrincipal, BorderLayout.NORTH);
+		
+		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		
+		this.setSize(largeurFenetre,(int) ((largeurFenetre * 3) / 4));
+		this.setLocation(200,200);
+		this.setResizable(false);
+		this.setTitle("Blankuissance 4");
+		
+		// ***************************************************** //
+		
+		// menu Jeu - bouton Nouveau
+		MenuJeu_Nouveau.addActionListener(new ActionListener(){
+			public void actionPerformed(ActionEvent ev){
+				menuJeuNouveau();
+			}
+		});
+		
+		// menu Jeu - bouton Quitter
+		MenuJeu_Quitter.addActionListener(new ActionListener(){
+			public void actionPerformed(ActionEvent ev){
+				menuJeuQuitter();
+			}
+		});
+
+		// menu Apropos - bouton
+		MenuAide_Apropos.addActionListener(new ActionListener(){
+			public void actionPerformed(ActionEvent ev){
+				menuApropos();
+			}
+		});
+	}
+	
+/**
+ * 
+ * @author olivier
+ *
+ */
+/**
+ * On etend la classe JButton a une classe BoutonBlanko pour dessiner des boutons differents
+ */
+class BoutonBlanko extends JButton {
+		
+		public static final long serialVersionUID = 1L;
+		
+		/**
+		 * Degrade noir
+		 */
+		private GradientPaint degrade = new GradientPaint(100,100,Color.WHITE,170, 0,Color.BLACK);
+		/**
+		 * Et la couleur B qui va avec (blanche)
+		 */
+		private String couleur = new String("B");
+		
+		/**
+		 * Redefinition de la methode paintComponent pour dessiner le bouton
+		 */
+		public void paintComponent(Graphics g) {
+			
+			super.paintComponent(g);
+			Graphics2D g2 = (Graphics2D) g;
+			
+			g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
+
+			// Calcuel dynamiquement les informations de taille (pris de JavaDoc)
+	        Dimension size = getSize();
+	        // diametre
+	        int d;
+	        int x;
+	        int y;
+	        
+	        // On enleve les bordures des boutons
+	        this.setBorderPainted(false);
+	        // puis le fait que lorsque nous cliquons sur le bouton il y ait un carre gris de selection
+	        this.setEnabled(false);
+	        
+	        // Calcul des donnees du cercle fonce
+	        d = (int) ( Math.min(size.width, size.height) * .80 * 1.10);
+	        x = (size.width - d)/2;
+	        y = (size.height - d)/2;
+	        
+	        g2.setColor(new Color(17,53,188));
+	        g2.fillOval(x ,y ,d ,d);
+	        
+	        // Calcul des donnees du cercle intermediaire
+	        d = (int) ( Math.min(size.width, size.height) * .80 * 1.05);
+	        x = (size.width - d)/2;
+	        y = (size.height - d)/2;
+	        
+	        g2.setColor(Color.BLACK);
+	        g2.fillOval(x ,y ,d ,d);
+	        
+	        // Calcul des donnees du cercle interieur blanc
+	        d = (int) ( Math.min(size.width, size.height) * .80 );
+	        x = (size.width - d)/2;
+	        y = (size.height - d)/2;
+	        // dessine le cercle blanc
+	        g2.setPaint(degrade);
+	        g2.fillOval(x, y, d, d);
+	        
+		}
+		
+		/**
+		 * 
+		 * @param couleurChoisie - Couleur que nous voulons (normalement une lettre)
+		 * @param gp - Degrade de peinture
+		 * @return La couleur a ete correctement mise ou pas ?
+		 */
+		/**
+		 * On ajoute une couleur au bouton et on verifie si elle a bien ete appliquee
+		 */
+		public boolean setCouleur(String couleurChoisie, GradientPaint gp){
+			if(!couleur.equals("R") && !couleur.equals("J")){
+				if(couleur.equals("R")){
+					this.couleur = "R";
+				}
+				else {
+					this.couleur = "J";
+				}
+				degrade = gp;
+
+				return true;
+			}
+			else {
+				couleur.equals("B");
+				return false;
+			}
+		}
+	}
+	
+	/**
+	 * <p>Action du bouton Quitter du menu Jeu</p>
+	 *
+	 */
+	private void menuJeuQuitter(){
+		System.exit(0);
+	}
+
+	/**
+	 * <p>Action du bouton Nouveau du menu Jeu</p>
+	 * @param args
+	 */	
+	private void menuJeuNouveau(){
+		
+		// On initialise le plateau de jeu
+		p4.initialiser();
+		
+		// Creation d'un joueur generique
+		joueur = new Joueurs("joueur de base", " ");
+		
+		// On alterne de joueur, on recupere donc le joueur en cours
+		joueur = p4.alterneJoueur((Joueurs)p4.getJoueurs().get(1), (Joueurs)p4.getJoueurs().get(2));
+		
+		// On remet le nombre de pions à 0
+		comptePion = 0;
+		
+		aucunGagnant = true;
+		
+		this.remove(Panneau_Centre);
+		Panneau_Centre = new JPanel();
+		Panneau_Centre.setLayout(new GridLayout(p4.nbreLignes,p4.nbreColonnes));
+		for(int i = 0; i < p4.nbreLignes; i++){
+			for(int j = 0; j < p4.nbreColonnes; j++){
+				BoutonBlanko moi = new BoutonBlanko();
+				moi.setBackground(Color.GRAY);
+				
+				// menu Fichier - bouton Quitter
+				moi.addMouseListener(new MouseListener() {
+					public void mouseClicked(MouseEvent ev) {
+						actionGrille(ev);
+					}
+					public void mouseExited(MouseEvent ev) {
+						enleveSurbrillance(ev);
+					}
+					public void mouseReleased(MouseEvent ev){
+						
+					}
+					public void mousePressed(MouseEvent ev){
+						
+					}
+					public void mouseEntered(MouseEvent ev){
+						surbrillanceCellule(ev);
+					}
+				});
+				
+				Panneau_Centre.add(moi);
+			}
+		}
+		Panneau_Centre.setBorder(new BevelBorder(BevelBorder.RAISED));
+		this.add(Panneau_Centre, BorderLayout.CENTER);
+		
+		LabelStatut.setText("Selectionnez une colonne puis cliquez dessus.");
+		
+		this.validate();
+	}
+	
+	/**
+	 * <p>Action du bouton Apropos du menu Aide</p>
+	 * @param args
+	 */
+	private void menuApropos(){
+		JOptionPane.showMessageDialog(null, "Blankuissance4\n\n" +
+				"Version 0.5\n" +
+				"Developpe par Blankoworld\n\n",
+				"A propos de Blankuissance4",
+				JOptionPane.QUESTION_MESSAGE);
+	}
+	
+	/**
+	 * <p>Action sur la grille du plateau de jeu</p>
+	 * @param ev
+	 */
+	private void actionGrille(MouseEvent ev){
+		
+		boolean resultat;
+		String couleur;
+		
+		// Degrades de couleurs rouges et jaunes
+		degradeRouge = new GradientPaint(100,100,Color.RED,(int) (this.getHeight() * 0.15), 0,Color.WHITE);
+		degradeJaune = new GradientPaint(100,100,Color.YELLOW,(int) (this.getHeight() * 0.15), 0,Color.WHITE);
+		
+		// Un nouveau bouton pour travailler dessus
+		BoutonBlanko bb = new BoutonBlanko();
+		BoutonBlanko bbModif = new BoutonBlanko();
+		
+		// On recupere le bouton sur lequel nous travaillons
+		bb = (BoutonBlanko) ev.getSource();
+		
+		// Definition de la colonne dans laquelle nous nous trouvons
+		int colonne = (int) (bb.getX() / bb.getWidth()) + 1;
+		// Definition de la ligne ou nous nous trouvons
+//		int ligne = (int) (bb.getY() / bb.getHeight()) + 1;
+		// Definition et calcul du numero du pion sur lequel nous venons de cliquez dans le tableau GRAPHIQUE
+//		int numeroPosAct = ((ligne - 1) * p4.nbreColonnes) + (colonne - 1);
+		
+		// On defini la position reelle pour placer notre pion
+		int PositionColonne = p4.getPosition(colonne - 1);
+		
+		if(aucunGagnant && PositionColonne < p4.nbreLignes && comptePion < p4.nbreColonnes * p4.nbreLignes) {
+			
+			int numeroPlacement = (((p4.nbreLignes - 1 - PositionColonne) * p4.nbreColonnes) + (colonne - 1));
+			
+//			LabelStatut.setText("Colonne: " + colonne + " Ligne: " + ligne + " Numero: " + 
+//			numeroPosAct + " Position de la colonne: " + PositionColonne + " Numero à placer: " + numeroPlacement);
+			LabelStatut.setText("Le " + joueur.getNom() + " a jete son pion dans la colonne " + colonne);
+			
+			// On veut donner le prochain joueur, le programme etant mal fichu, il faut alterner puis revenir en arriere
+			p4.setAlternanceJoueur();
+			joueur = p4.alterneJoueur((Joueurs)p4.getJoueurs().get(1), (Joueurs)p4.getJoueurs().get(2));
+			LabelInfos.setText(joueur.getNom() + ", c'est a vous !");
+			p4.setAlternanceJoueur();
+			joueur = p4.alterneJoueur((Joueurs)p4.getJoueurs().get(1), (Joueurs)p4.getJoueurs().get(2));
+			
+			bbModif = (BoutonBlanko) Panneau_Centre.getComponent(numeroPlacement);
+			
+			if(joueur.donneJeton().getCouleur().equals("R")){
+				couleur = "R";
+				resultat = bbModif.setCouleur(couleur, degradeRouge);
+			}
+			else{
+				couleur = "J";
+				resultat = bbModif.setCouleur(couleur, degradeJaune);
+			}
+			
+			if(p4.getPosition(colonne - 1) < p4.nbreLignes){
+				// On ajoute le pion au tableau du plateau
+				p4.ajoutPion(colonne - 1, couleur);
+				
+//				// Affichage en console de la grille pour verification
+//				p4.afficherGrille();
+			}
+			
+			bbModif.repaint();
+			if(resultat){
+				// On ajoute un pion au nombre de pions utilises
+				comptePion++;
+				
+				// On confirme que le joueur a joue et qu'on change de joueur
+				p4.setAlternanceJoueur();
+				joueur = p4.alterneJoueur((Joueurs)p4.getJoueurs().get(1), (Joueurs)p4.getJoueurs().get(2));
+			}
+			
+			// Mise a niveau de la colonne vis a vis de la structure Java (commence à 0)
+			colonne --;
+			
+			if(comptePion > 5 && p4.gagnant(colonne, p4.getPosition(colonne) - 1)){
+				comptePion = 41;
+				// On alterne de joueur (oui programme mal fichu !)
+				p4.setAlternanceJoueur();
+				joueur = p4.alterneJoueur((Joueurs)p4.getJoueurs().get(1), (Joueurs)p4.getJoueurs().get(2));
+				JOptionPane.showMessageDialog(null, "Le " + joueur.getNom() + " gagne !", "Message", JOptionPane.INFORMATION_MESSAGE);
+				aucunGagnant = false;
+				LabelInfos.setText("Aucun joueur");
+				LabelStatut.setText("Merci aux participants !");
+			}
+		}
+		else if(comptePion >= 41){
+			LabelStatut.setText("Jeu fini !");
+		}
+		else {
+			LabelStatut.setText("Vous ne pouvez plus jouer dans cette colonne. Choisissez une autre colonne.");
+		}
+		
+		// Repeinte du champ de texte nomme Statut
+		LabelStatut.repaint();
+		// Idem avec Infos
+		LabelInfos.repaint();
+	}
+	
+	/**
+	 * <p>Met le bouton choisi en surbrillance</p>
+	 * @param ev - Evenement lie au clic de souris
+	 */
+	public void surbrillanceCellule(MouseEvent ev){
+		// Un nouveau bouton pour travailler dessus
+		BoutonBlanko bb = new BoutonBlanko();
+		BoutonBlanko bbModif = new BoutonBlanko();
+		
+		// On recupere le bouton sur lequel nous travaillons
+		bb = (BoutonBlanko) ev.getSource();
+		
+		// Definition de la colonne dans laquelle nous nous trouvons
+		int colonne = (int) (bb.getX() / bb.getWidth()) + 1;
+		
+		for(int i = 0; i < p4.nbreLignes; i++){
+			
+			int numeroPlacement = (((p4.nbreLignes - 1 - i) * p4.nbreColonnes) + (colonne - 1));
+			bbModif = (BoutonBlanko) Panneau_Centre.getComponent(numeroPlacement);
+			bbModif.setBackground(new Color(213,213,213,125));
+			bbModif.repaint();
+		}
+		
+		LabelInfos.setText(joueur.getNom() + " est sur colonne " + colonne + ".");
+
+		LabelStatut.repaint();
+	}
+	
+	/**
+	 * <p>Enleve la surbrillance</p>
+	 * @param ev - Evenement lie au clic de souris
+	 */
+	public void enleveSurbrillance(MouseEvent ev){
+		// Un nouveau bouton pour travailler dessus
+		BoutonBlanko bb = new BoutonBlanko();
+		BoutonBlanko bbModif = new BoutonBlanko();
+		
+		// On recupere le bouton sur lequel nous travaillons
+		bb = (BoutonBlanko) ev.getSource();
+		
+		// Definition de la colonne dans laquelle nous nous trouvons
+		int colonne = (int) (bb.getX() / bb.getWidth()) + 1;
+		
+		for(int i = 0; i < p4.nbreLignes; i++){
+			
+			int numeroPlacement = (((p4.nbreLignes - 1 - i) * p4.nbreColonnes) + (colonne - 1));
+			bbModif = (BoutonBlanko) Panneau_Centre.getComponent(numeroPlacement);
+			bbModif.setBackground(Color.GRAY);
+			bbModif.repaint();
+		}
+
+	}
+	
+	/**
+	 * Methode principale MAIN
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		new IhmPuissance4().setVisible(true);
+		
+	}
+
+}

G5a/Puissance4/fr/blankoworld/plateau/Jeton.java

@@ -0,0 +1,58 @@
+package fr.blankoworld.plateau;
+
+/**
+ * 
+ * @author olivier DOSSMANN
+ *
+ */
+/**
+ * Permet de creer des jetons pour le Blankuissance 4
+ */
+public class Jeton {
+	/**
+	 * Couleur du jeton
+	 */
+	private String couleur;
+	
+	/**
+	 * 
+	 * @param colorimetrie - Couleur du jeton
+	 */
+	/**
+	 * Instanciation d'un nouveau jeton avec une couleur particuliere
+	 */
+	public Jeton(String colorimetrie){
+		couleur = colorimetrie;
+	}
+	
+	/**
+	 * Recupere la couleur du jeton
+	 * @return couleur du jeton
+	 */
+	public String getCouleur(){
+		return couleur;
+	}
+	
+	/**
+	 * 
+	 * @param clr - couleur souhaite du jeton
+	 */
+	/**
+	 * Donne une couleur au jeton
+	 */
+	public void setCouleur(String clr){
+		this.couleur = clr;
+	}
+	
+	/**
+	 * 
+	 * @param jtn - Jeton a compare avec celui en cours
+	 * @return Different ou non au jeton compare ?
+	 */
+	/**
+	 * Compare le jeton actuel et un autre jeton donne en parametre
+	 */
+	public boolean estMemeCouleur(Jeton jtn){
+		return (jtn.getCouleur().equals(this.couleur));
+	}
+}

G5a/Puissance4/fr/blankoworld/plateau/Joueurs.java

@@ -0,0 +1,80 @@
+package fr.blankoworld.plateau;
+
+/**
+ * 
+ * @author olivier DOSSMANN
+ *
+ */
+/**
+ * Permet de creer des joueurs de Blankuissance 4 avec leur jeton
+ */
+public class Joueurs {
+	
+	/**
+	 * Nom du joueur
+	 */
+	private String nomJoueur;
+	/**
+	 * Jeton du joueur
+	 */
+	private Jeton jetonJoueur;
+	
+	/**
+	 * Nombre de joueurs instancies
+	 */
+	public int s_nombreJoueurs;
+	
+	/**
+	 * 
+	 * @param nom - Nom du joueur
+	 * @param couleur - couleur de son pion
+	 */
+	/**
+	 * Constructeur de la classe Joueurs
+	 */
+	public Joueurs(String nom, String couleur){
+		nomJoueur = nom;
+		jetonJoueur = new Jeton(couleur);
+		s_nombreJoueurs++;
+	}
+	
+	/**
+	 * Methode qui retourne le nom du joueur et la couleur du joueur en cours
+	 */
+	public String toString(){
+		return "Joueur : " + nomJoueur + "\nCouleur : " + this.jetonJoueur.getCouleur();
+	}
+	
+	/**
+	 * 
+	 * @return Nom du joueur
+	 */
+	/**
+	 * Recupere le nom du joueur
+	 */
+	public String getNom(){
+		return this.nomJoueur;
+	}
+	
+	/**
+	 * 
+	 * @param nom - Nom du joueur
+	 */
+	/**
+	 * Permet de changer/donner le nom du joueur
+	 */
+	public void setNom(String nom){
+		this.nomJoueur = nom;
+	}
+	
+	/**
+	 * 
+	 * @return recupere le jeton du joueur
+	 */
+	/**
+	 * Avez vous besoin du jeton du joueur ? Oui ? Alors vous etes au bon endroit
+	 */
+	public Jeton donneJeton(){
+		return this.jetonJoueur;
+	}
+}

G5a/Puissance4/fr/blankoworld/plateau/PlateauPuissance4.java

@@ -0,0 +1,396 @@
+package fr.blankoworld.plateau;
+
+import java.util.Vector;
+
+/**
+ * @author Olivier DOSSMANN
+ *
+ */
+/**
+ * Classe plateau qui permet de creer un plateau de jeu
+ */
+public class PlateauPuissance4 {
+
+	private Jeton[][] grille;
+	private int[] positions;
+	private boolean alternanceJoueur = true;
+	private Joueurs j1;
+	private Joueurs j2;
+	private Joueurs j0;
+	private Vector CollectionJoueurs;
+	
+	public int nbreColonnes = 7;
+	public int nbreLignes = 6;
+	
+/**
+ * 
+ * @param args - Arguments passes en parametre
+ */
+/**
+ * Methode principale MAIN
+ */
+	public static void main(String args[]){
+//		System.out.println("Bienvenue dans Blankuissance4, le nouveau jeu fecal de puissance 4 !");
+		
+		// Instanciation de l'objet a partir de la classe PlateauPuissance4
+		PlateauPuissance4 p4 = new PlateauPuissance4();
+		
+		p4.lancer();
+	}
+
+	/**
+	 * Initialisation des variables, des joueurs, de la grille, etc ...
+	 *
+	 */
+	public void initialiser()
+	{
+		// Initialisation des joueurs
+		j1 = new Joueurs("Joueur Un", "R");
+		j2 = new Joueurs("Joueur Deux", "J");
+		j0 = new Joueurs("Joueur inexistant", " ");
+		
+		// On remplit la collection de joueurs
+		CollectionJoueurs = new Vector();
+		CollectionJoueurs.add(j0);
+		CollectionJoueurs.add(j1);
+		CollectionJoueurs.add(j2);
+		
+		// Creation de la grille
+		grille = new Jeton[nbreColonnes][nbreLignes];
+		
+		// Creation tu tableau de positionnement
+		positions = new int[7];
+		
+		// Initialisation du tableau
+		for (int i = 0; i < nbreColonnes; i++){
+			for(int j = 0; j < nbreLignes; j++){
+				grille[i][j] = j0.donneJeton();
+			}
+		}
+		
+		// Initialisation des positions
+		for (int i = 0; i < nbreColonnes; i++){
+			positions[i] = 0;
+		}
+	}
+	
+	/**
+	 * Permet de relancer le jeu (prevu pour l'ajout supplementaire d'un menu)
+	 *
+	 */
+	public void reinitialiser(){
+		lancer();
+	}
+	
+	/**
+	 * Affiche la grille de jeu
+	 *
+	 */
+	public void afficherGrille(){
+		for (int i = nbreLignes - 1; i >= 0; i--){
+			for(int j = 0; j < nbreColonnes; j++){
+				System.out.print(grille[j][i].getCouleur() + "|");
+			}
+			System.out.print("\n");
+		}
+		for (int k = 0; k < nbreColonnes; k++){
+			System.out.print("--");
+		}
+		System.out.print("\n");
+		
+		for (int l = 0; l < nbreColonnes; l++){
+			System.out.print(Integer.toString(l + 1) + "|");
+		}
+		System.out.print("\n");
+	}
+	
+	/**
+	 * C'est ici que le jeu se deroule, que les appels sont faits, etc ...
+	 * Tout est la !
+	 *
+	 */
+	public void lancer(){
+		System.out.println("Lancement du jeu de plateau");
+		
+		// Initialisation du plateau
+		this.initialiser();
+		
+		// Affichage du plateau pour verification
+		this.afficherGrille();
+		
+		// Creation d'une aide pour les entrees de l'utilisateur
+		AideSaisie aide = new AideSaisie();
+		
+		// Affichage des joueurs
+		System.out.println("Affichage des deux joueurs : ");
+		System.out.println(" - " + j1.toString() + ".");
+		System.out.println(" - " + j2.toString() + ".");
+		
+		// Creation d'un joueur generique
+		Joueurs joueur = new Joueurs("joueur de base", " ");
+		
+		// Numero de colonne choisi
+		int colonne = 0;
+		
+		// incrementeur de jetons
+		int i = 0;
+		
+		// Contrele d'entree de boucle
+		boolean aGagne = false;
+		
+		while (aGagne == false && i < (nbreColonnes * nbreLignes))
+		{
+
+			// Methode pour alterner de joueur : entre le joueur Un et le joueur Deux
+			joueur = alterneJoueur(j1,j2);
+			
+			boolean ok = true;
+			// Recuperation de la proposition de colonne de l'utilisateur
+			while(ok){
+				String proposition = aide.getEntreeUtilisateur("Colonne (entre 1 et " + nbreColonnes + ") : ");
+				System.out.println("Colonne choisie par " + joueur.getNom() + " : " + proposition);
+				
+				// Traduction en entier du numero de colonne
+				if (proposition == null){
+					colonne = nbreColonnes;
+				}
+				else{
+					colonne = Integer.parseInt(proposition);
+					
+					// Mise a niveau de la colonne vis a vis de la structure Java
+					colonne --;
+				}
+				
+				// Verification que la colonne n'est pas pleine ou hors limite
+				if (colonne > nbreColonnes - 1 || colonne < 0){
+					ok = true;
+					System.out.println("Hors limites !");
+				}
+				else if (!grille[colonne][5].getCouleur().equals(" ")){
+					ok = true;
+					System.out.println("Colonne a ras bord !");
+				}
+				else{
+					ok = false;
+					System.out.println("Longueur du tableau : " + grille[colonne].length);
+					
+					// Si colonne pas pleine, verifier a quel position les pions precedents sont poses
+					// Si aucun pion, alors poser tout en bas
+					
+					this.ajoutPion(colonne, joueur.donneJeton().getCouleur());
+					this.afficherGrille();
+				}
+			}
+			
+			// Il faut minimum 7 pions poses, avant de savoir si le joueur a gagne ou pas
+			// Comme nous commencons a 0 l'incr<63>menteur (7 - 1 = 6), et que le jeton actuel 
+			// n'est pas encore compte (6 - 1 = 5),
+			//  alors on met la valeur a 5. C'est a dire que nous aurons deja i a 7 au minimum quand on fera
+			//  ce test, et que nous serons dans le cas du 8i<38>me jeton.
+			if (i > 5){
+				
+				// Verification si le joueur gagne
+				//	On decremente de 1 positions[colonne] car nous y avons ajoute 1 pour le pion suivant
+				aGagne = gagnant(colonne, positions[colonne] - 1);
+			}
+			
+			// Instanciation de i pour confirmer que le coup est lance
+			i++;
+			// Idem mais alternance du joueur
+			alternanceJoueur = !alternanceJoueur;
+			System.out.println("Coup numero " + i + " joue !");
+			System.out.print("\n");
+		}
+	
+		if (i < (nbreColonnes * nbreLignes)){
+			System.out.println(joueur.getNom() + " a gagne !");
+			System.out.println("Merci au joueur de l'autre equipe d'avoir participe.");
+		}
+		else{
+			System.out.println("Jeu termine, aucun gagnant !");
+			System.out.println("Merci d'avoir joue.");
+		}
+	}
+	
+	/**
+	 * 
+	 * @param jUn - Joueur Un
+	 * @param jDeux - Joueur Deux
+	 * @return Joueur qui dois jouer
+	 */
+	/**
+	 * On recupere le joueur qui doit jouer
+	 */
+	public Joueurs alterneJoueur(Joueurs jUn, Joueurs jDeux){
+		
+		if (alternanceJoueur){
+			return jUn;
+		}
+		else{
+			return jDeux;
+		}
+	}
+	
+	/**
+	 * 
+	 * @param positionColonne - Position de la colonne choisie
+	 * @param couleur - Couleur du pion pose
+	 */
+	/**
+	 * Ajoute un pion dans la colonne choisie en donnant la couleur dudit pion
+	 */
+	public void ajoutPion(int positionColonne, String couleur){
+		Jeton nouveauPion = new Jeton(couleur);
+		int positionJeton = positions[positionColonne];
+		
+		grille[positionColonne][positionJeton] = nouveauPion;
+		positions[positionColonne] ++;
+	}
+	
+	/**
+	 * 
+	 * @param colonneChoisie - Colonne que l'utilisateur a choisi
+	 * @param positionPion - Position du pion dans ladite colonne
+	 * @return Avons nous un gagnant ? Oui ou non ?
+	 */
+	/**
+	 * Determine si le pion pose donne un jeu gagnant au joueur qui l'a pose ou pas
+	 */
+	public boolean gagnant(int colonneChoisie, int positionPion){
+		
+		// Entier qui permet de definir le nombre de puissance 4 effectues
+		int puissance4 = 1;
+		
+		puissance4 = estAligne(2,0,colonneChoisie,positionPion) + estAligne(1,0,colonneChoisie,positionPion) + 1;
+		if( puissance4 < 4){
+			//System.out.println(puissance4);
+			puissance4 = estAligne(0,2,colonneChoisie,positionPion) + estAligne(0,1,colonneChoisie,positionPion) + 1;
+			if(puissance4 < 4){
+				//System.out.println(puissance4);
+				puissance4 = estAligne(2,2,colonneChoisie,positionPion) + estAligne(1,1,colonneChoisie,positionPion) + 1;
+				if(puissance4 < 4){
+					//System.out.println(puissance4);
+					puissance4 = estAligne(1,2,colonneChoisie,positionPion) + estAligne(2,1,colonneChoisie,positionPion) + 1;
+					if(puissance4 < 4){
+						//System.out.println(puissance4);
+						return false;
+					}
+					else return true;
+				}
+				else return true;
+			}
+			else return true;
+		}
+		else return true;
+	}
+	
+	/**
+	 * 
+	 * @param X - Valeur 0,1 ou 2. Avec 1 nous incrementons, avec 2 l'inverse, et avec 0 nous ne faisons rien
+	 * @param Y - Idem que X
+	 * @param colonneChoisie - Colonne de laquelle nous partons
+	 * @param positionPion - position du pion de lequel nous partons
+	 * @return Avons nous une ligne de puissance 4 ? Combien de pions alors ?
+	 */
+	/**
+	 * Renvoie le nombre de pions de meme couleur alignes
+	 */
+	public int estAligne(int X, int Y, int colonneChoisie, int positionPion){
+		int puissance4 = 0;
+		boolean ok = true;
+		int colonneTestee = colonneChoisie, ligneTestee = positionPion;
+
+		// Verification à l'écran que nous nous trouvons au bon endroit
+		//System.out.println("X: " + X + " Y: " + Y + " Colonne choisie: " + colonneChoisie + " Position choisie: " + positionPion);
+		
+		if(Y == 1){
+			colonneTestee++;
+		}
+		else if(Y == 2){
+			colonneTestee--;
+		}
+		else{
+			// Rien
+		}
+		if(X == 1){
+			ligneTestee++;
+		}
+		else if(X == 2){
+			ligneTestee--;
+		}
+		else{
+			// Rien
+		}
+		
+		if(colonneTestee < 0 || colonneTestee > nbreColonnes - 1){
+			ok = false;
+		}
+		if(ligneTestee < 0 || ligneTestee > nbreLignes - 1){
+			ok = false;
+		}
+		
+		//System.out.println("Debut des tests : " + ligneTestee);
+		while(ok == true && grille[colonneTestee][ligneTestee].getCouleur().equals(grille[colonneChoisie][positionPion].getCouleur())){
+			puissance4++;
+			if(Y == 1){
+				colonneTestee++;
+			}
+			else if(Y == 2){
+				colonneTestee--;
+			}
+			else{
+				// Rien
+			}
+			if(X == 1){
+				ligneTestee++;
+			}
+			else if(X == 2){
+				ligneTestee--;
+			}
+			else{
+				// Rien
+			}
+			//System.out.println("Colonne : " + colonneTestee + ". Ligne : " + ligneTestee);
+			if(colonneTestee < 0 || colonneTestee > nbreColonnes - 1){
+				ok = false;
+			}
+			if(ligneTestee < 0 || ligneTestee > nbreLignes - 1){
+				ok = false;
+			}
+		}
+		
+		return puissance4;
+	}
+	
+	/**
+	 * 
+	 * @param colonne - Colonne choisise
+	 * @return Position du pion dans la colonne
+	 */
+	/**
+	 * Permet de recuperer la position du pion dans une colonne donnee
+	 */
+	public int getPosition(int colonne)
+	{
+		return positions[colonne];
+	}
+	
+	/**
+	 * 
+	 * @return Collection de joueurs
+	 */
+	/**
+	 * On recupere une collection de joueurs sous forme de Vecteurs
+	 */
+	public Vector getJoueurs(){
+		return CollectionJoueurs;
+	}
+	
+	/**
+	 * Affirme que nous changeons de joueurs (ce qui n'inclue pas le fait que nous ayons a le recuperer !)
+	 *
+	 */
+	public void setAlternanceJoueur(){
+		alternanceJoueur = !alternanceJoueur;
+	}
+}