Merge origin/master

AlgoRechercheAleatoire

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package tictactoecodingame;
+
+import java.util.ArrayList;
+import java.util.Random;
+
+/**
+ *
+ * @author franck.tempet
+ */
+public class AlgoRechercheAleatoire extends AlgoRecherche{
+    Random rnd;
+
+    public AlgoRechercheAleatoire() {
+        rnd = new Random();       
+    }
+    
+    
+    
+    @Override
+    public Coup meilleurCoup(Plateau _plateau, Joueur _joueur, boolean _ponder) {
+        
+        ArrayList<Coup> coups = _plateau.getListeCoups(_joueur);
+        
+        return coups.get(rnd.nextInt( coups.size()));
+    }
+
+   
+    
+}

Arbitre

+package tictactoecodingame;
+
+
+/**
+ * @author  Franck
+ *
+ */
+public class Arbitre {
+
+    Joueur joueur1;         // Joueur qui commence la partie
+    Joueur joueur2;         // Adversaire
+    Joueur currentJoueur;   // C'est à son tour de jouer
+    Plateau plateau;        // Le plateau du jeu
+
+    public Arbitre(Plateau _plateau, Joueur _joueur1, Joueur _joueur2) {
+        plateau = _plateau;
+        joueur1 = _joueur1;
+        joueur2 = _joueur2;
+        currentJoueur = joueur1;     // Le joueur1 commence la partie.        
+    }
+
+    /**
+     * Demarre une nouvelle Partie
+     * Retourne le joueur qui gagne , null si c'est un match nul
+     *
+     * @param _trace   si vrai affiche le plateau et le joueur courant
+     */
+    public Joueur startNewGame( boolean _trace ) {
+        Coup coup;
+
+        plateau.init();		     // Prépare le plateau pour le jeu.
+        
+        
+        while (!plateau.partieTerminee()) {
+            do {
+                if ( _trace ) {
+                    System.out.println(plateau);
+                    System.out.println(currentJoueur + " ( " +currentJoueur.getIdJoueur() + "  )  joue : " );
+                }
+                coup = currentJoueur.joue(plateau);
+
+                if (!plateau.isValide(coup)) {
+                    if ( _trace )
+                        System.err.println("Coup non valide ! : " + currentJoueur);
+                    else {  // en mode batch le joueur perd la partie
+                        System.err.println("Coup non valide ! : " + currentJoueur);
+                        if (currentJoueur == joueur1) return joueur2; else return joueur1;
+                    }
+                }
+
+            } while (!plateau.isValide(coup));
+
+            plateau.joueCoup(coup);
+            
+            
+            if (currentJoueur == joueur1) {
+                currentJoueur = joueur2;
+            } else {
+                currentJoueur = joueur1;
+            }
+        }
+        
+        Joueur vainqueur = plateau.vainqueur();
+        if ( vainqueur != null )
+            System.out.println( vainqueur + " gagne la partie ");
+        else
+            System.out.println( "Partie nulle ");
+        
+        return vainqueur;
+
+    }
+    
+    public void startTournament( int _nbPartie , boolean _trace) {
+        double[] nbVictoire = new double[2]; 
+        Joueur vainqueur;
+        
+        currentJoueur = joueur1;
+        int numJoueur = 0;
+        
+        nbVictoire[0] = nbVictoire[1]  = 0;
+        for (int i = 0 ; i < _nbPartie ; i++ ) {
+            vainqueur = startNewGame(_trace);
+            
+            if ( vainqueur == joueur1 ) nbVictoire[0]++;
+            if ( vainqueur == joueur2 ) nbVictoire[1]++;
+            
+            if ( vainqueur == null ) {
+                nbVictoire[0]+=0.5;
+                nbVictoire[1]+=0.5;
+            }
+
+            if ( numJoueur == 0  )  {              
+                currentJoueur = joueur2;
+                numJoueur=1;
+            }
+            else {
+                currentJoueur = joueur1;
+                numJoueur=0;
+            }
+            System.out.println(joueur1 + " score : " + nbVictoire[0]);
+            System.out.println(joueur2 + " score : " + nbVictoire[1]);
+
+        }
+        
+        System.out.println(joueur1 + " score : " + nbVictoire[0]);
+        System.out.println(joueur2 + " score : " + nbVictoire[1]);
+        
+        if (nbVictoire[0] > nbVictoire[1]) 
+            System.out.println(joueur1 + " GAGNE ");
+        else
+        if (nbVictoire[1] > nbVictoire[0]) 
+            System.out.println(joueur2 + " GAGNE ");
+        else
+            System.out.println("Match nul");               
+    }
+
+    public Joueur getCurrentJoueur() {
+        return currentJoueur;
+    }
+}
\ No newline at end of file

Case

+package tictactoecodingame;
+
+
+/**
+ * @author Franck
+ */
+public class Case {
+
+    int colonne, ligne;
+
+    public Case(int _colonne, int _ligne) {
+        this.colonne = _colonne;
+        this.ligne = _ligne;
+    }
+
+    public int getColonne() {
+        return colonne;
+    }
+
+    public int getLigne() {
+        return ligne;
+    }
+    
+   public void setLigne( int _ligne ) {
+        this.ligne = _ligne;
+    }
+
+   public void setColonne( int _colonne ) {
+        this.colonne = _colonne;
+    }
+      
+}

Coup

+package tictactoecodingame;
+
+
+/**
+ * @author Franck
+ */
+public abstract class Coup {
+
+    private int note;
+
+    public Coup() {
+        note = Integer.MIN_VALUE;  // un coup est tres mauvais tant qu'il n'est pas analysé.
+    }
+
+    public void setNote(int _note) {
+        note = _note;
+    }
+
+    public int getNote() {
+        return note;
+    }
+
+    abstract public String toString();
+    
+    abstract public boolean equals(Object obj);
+    
+    abstract public int hashCode();
+    
+}

CoupTicTacToe

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package tictactoecodingame;
+
+
+/**
+ *
+ * @author franck.tempet
+ */
+public class CoupTicTacToe extends Coup {
+    private int colonne, ligne;
+    private Jeton jeton;
+
+    public CoupTicTacToe( int _colonne , int _ligne , Jeton _jeton ) {
+        super();
+        colonne = _colonne;
+        ligne = _ligne;       
+        jeton = _jeton;
+    }
+    
+    public int getColonne() {
+        return colonne;
+    }
+
+    public int getLigne() {
+        return ligne;
+    }
+    
+    public Jeton getJeton() {
+        return jeton;
+    }
+
+    public String toString() {
+        return "(" + colonne + "," + ligne + ")" ;
+    }
+
+            
+    @Override
+    public boolean equals(Object obj) {
+        if ( obj == null )  return false;
+        
+        if (this.getClass() != obj.getClass()) return false;
+        
+        CoupTicTacToe coup = (CoupTicTacToe)obj;
+        
+        return colonne == coup.getColonne() && ligne==coup.ligne && jeton.toString().equals(coup.getJeton().toString());
+        
+    }
+
+    @Override
+    public int hashCode() {
+        return jeton.toString().hashCode() + colonne * 10 + ligne;
+    }
+    
+
+}

GrilleTicTacToe3x3

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package tictactoecodingame;
+
+import java.util.ArrayList;
+
+/**
+ *
+ * @author franck.tempet
+ */
+public class GrilleTicTacToe3x3 extends Plateau {
+
+    Jeton[][] grille = new Jeton[3][3];
+    Jeton[][][] grilleSav = new Jeton[100][3][3];  // Pour sauvegardr la position. 100 au maximum
+
+    CoupTicTacToe dernierCoup;
+    Joueur vainqueur;
+
+    @Override
+    public void init() {
+        for (int c = 0; c < this.getNbColonnes(); c++) 
+            for (int l = 0; l < this.getNbLignes(); l++) 
+                grille[c][l] = null;                    
+        
+        dernierCoup = null;
+        vainqueur = null;
+    }
+
+    @Override
+    public Piece getPiece(Case _case) {
+        return grille[_case.getColonne()][_case.getLigne()];
+    }
+
+    @Override
+    public void joueCoup(Coup _coup) {
+        CoupTicTacToe coup = (CoupTicTacToe) _coup;
+
+        grille[coup.getColonne()][coup.getLigne()] = coup.getJeton();
+
+        dernierCoup = coup;
+    }
+
+    @Override
+    public void annuleDernierCoup() {
+        grille[dernierCoup.getColonne()][dernierCoup.getLigne()] = null;
+        dernierCoup = null;
+    }
+
+    @Override
+    public int getNbColonnes() {
+        return 3;
+    }
+
+    @Override
+    public int getNbLignes() {
+        return 3;
+    }
+
+    @Override
+    public boolean partieTerminee() {
+        if (partieGagnee()) {
+            return true;
+        }
+
+        return isGrillePleine();
+    }
+
+    @Override
+    public boolean partieGagnee() {
+        int[][] dir = {{1, 0}, {1, 1}, {0, 1}, {1, -1}};
+        int[][] dirOps = {{-1, 0}, {-1, -1}, {0, -1}, {-1, 1}};
+
+        int x, y;
+
+        int nbJetonAligne;
+
+        if (dernierCoup == null) {
+            return false;
+        }
+
+        Joueur dernierJoueur = dernierCoup.getJeton()
+                .getJoueur();
+
+        /* Regarde si le dernier coup est gagnant */
+        for (int d = 0; d < 4; d++) {
+            nbJetonAligne = 0;
+            x = dernierCoup.getColonne();
+            y = dernierCoup.getLigne();
+
+            while (x < this.getNbColonnes() && x >= 0 && y < this.getNbLignes() && y >= 0 && grille[x][y] != null && grille[x][y].getJoueur() == dernierJoueur) {
+                nbJetonAligne++;
+                if (nbJetonAligne >= 3) {
+                    vainqueur = dernierJoueur;
+                    return true;
+                }
+                x += dir[d][0];
+                y += dir[d][1];
+            }
+
+            //regarde dans la direction oppose    
+            x = dernierCoup.getColonne();
+            y = dernierCoup.getLigne();
+            nbJetonAligne--;
+
+            while (x < this.getNbColonnes() && x >= 0 && y < this.getNbLignes() && y >= 0 && grille[x][y] != null && grille[x][y].getJoueur() == dernierJoueur) {
+                nbJetonAligne++;
+                if (nbJetonAligne >= 3) {
+                    vainqueur = dernierJoueur;
+                    return true;
+                }
+                x += dirOps[d][0];
+                y += dirOps[d][1];
+            }
+        }
+
+        return false;
+
+    }
+
+    @Override
+    public boolean partieNulle() {
+        if (partieGagnee()) {
+            return false;
+        }
+
+        return isGrillePleine();
+    }
+
+    @Override
+    public ArrayList<Coup> getListeCoups(Joueur _joueur) {
+        
+        ArrayList<Coup> listeCoups = new ArrayList<Coup>();
+        
+        for (int c = 0; c < this.getNbColonnes(); c++) {
+            for (int l = 0; l < this.getNbLignes(); l++) {
+                if (grille[c][l] == null) 
+                    listeCoups.add(new CoupTicTacToe(c, l, new Jeton(_joueur)));               
+            }
+        }
+
+        return listeCoups;
+    }
+
+    @Override
+    public boolean isValide(Coup _coup) {
+        CoupTicTacToe coup = (CoupTicTacToe) _coup;
+
+        return grille[coup.getColonne()][coup.getLigne()] == null;
+    }
+
+    @Override
+    public Coup stringToCoup(String _coup, Joueur _joueur) {
+        int colonne = Integer.valueOf(_coup.charAt(0)+"");
+        int ligne = Integer.valueOf(_coup.charAt(1)+"");
+
+        return  new CoupTicTacToe(colonne, ligne , new Jeton(_joueur) );
+    }
+
+    @Override
+    public void sauvegardePosition(int _index) {
+        for (int c = 0; c < this.getNbColonnes(); c++) 
+            for (int l = 0; l < this.getNbLignes(); l++) 
+                   grilleSav[_index][c][l] = grille[c][l]; 
+
+    }
+
+    @Override
+    public void restaurePosition(int _index) {
+        for (int c = 0; c < this.getNbColonnes(); c++) 
+            for (int l = 0; l < this.getNbLignes(); l++) 
+                   grille[c][l] = grilleSav[_index][c][l]; 
+        
+        vainqueur = null;
+
+    }
+
+    private boolean isGrillePleine() {
+        for (int c = 0; c < this.getNbColonnes(); c++) {
+            for (int l = 0; l < this.getNbLignes(); l++) {
+                if (grille[c][l] == null) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public Joueur vainqueur() {
+       return vainqueur;
+    }
+
+
+    @Override
+    public Coup getDernierCoup() {
+        return dernierCoup;
+    }
+
+}

GrilleTicTacToe9x9

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package tictactoecodingame;
+
+import java.util.ArrayList;
+
+/**
+ *
+ * @author franck.tempet
+ */
+public class GrilleTicTacToe9x9 extends Plateau {
+
+    Jeton[][] grille9x9 = new Jeton[9][9];
+    Jeton[][] grille3x3 = new Jeton[3][3];  // indique si un joueur à gagné un case de la grande grille
+
+    Jeton[][][] grille9x9Sav = new Jeton[100][9][9];  // Pour sauvegarder la position. 100 positions Max
+    Jeton[][][] grille3x3Sav = new Jeton[100][3][3];  // Pour sauvegarder la position
+    int nbPostionSauvegarde;
+
+    CoupTicTacToe dernierCoup;
+    CoupTicTacToe dernierCoupSav;
+    Joueur vainqueur;
+    boolean grilleGagnee , grilleGagneeSav;  // vrai si dernier coup gagne une grille
+
+    @Override
+    public void init() {
+        for (int c = 0; c < this.getNbColonnes(); c++) {
+            for (int l = 0; l < this.getNbLignes(); l++) {
+                grille9x9[c][l] = null;
+            }
+        }
+
+        for (int c = 0; c < 3; c++) {
+            for (int l = 0; l < 3; l++) {
+                grille3x3[c][l] = null;
+            }
+        }
+        dernierCoup = null;
+        vainqueur = null;
+        grilleGagnee = false;
+        nbPostionSauvegarde = 0;
+    }
+
+    @Override
+    public Piece getPiece(Case _case) {
+        return grille9x9[_case.getColonne()][_case.getLigne()];
+    }
+
+    @Override
+    public void joueCoup(Coup _coup) {
+        CoupTicTacToe coup = (CoupTicTacToe) _coup;
+
+        grille9x9[coup.getColonne()][coup.getLigne()] = coup.getJeton();
+        dernierCoup = coup;
+        int x0 = (coup.getColonne() / 3) * 3;
+        int y0 = (coup.getLigne() / 3) * 3;
+
+      //  System.out.println("Test grande grille");
+        if (caseGagnante(grille9x9, x0, y0, coup.getColonne(), coup.getLigne())) {
+            grille3x3[coup.getColonne() / 3][coup.getLigne() / 3] = coup.getJeton();
+            grilleGagnee = true;
+        }
+            
+       
+    }
+
+    @Override
+    public void annuleDernierCoup() {
+        grille9x9[dernierCoup.getColonne()][dernierCoup.getLigne()] = null;
+        dernierCoup = null;
+    }
+
+    @Override
+    public int getNbColonnes() {
+        return 9;
+    }
+
+    @Override
+    public int getNbLignes() {
+        return 9;
+    }
+
+    @Override
+    public boolean partieTerminee() {
+
+        if (vainqueur != null) {
+            return true;
+        }
+
+        if (partieGagnee()) {
+            return true;
+        }
+
+        return isGrillePleine();
+    }
+
+    /**
+     * Regarde si le joueur vient de gagner sur une case en 3x3
+     *
+     * @param _grille soit la grille 9x9 soit la grille 3x3
+     * @param _x0 x min de la grille à analyser
+     * @param _y0 y min de la grille à analyser
+     * @param _coupX où le joueur a joué
+     * @param _coupY
+     * @return
+     */
+    public boolean caseGagnante(Jeton[][] _grille, int _x0, int _y0, int _coupX, int _coupY) {
+        int[][] dir = {{1, 0}, {1, 1}, {0, 1}, {1, -1}};
+        int[][] dirOps = {{-1, 0}, {-1, -1}, {0, -1}, {-1, 1}};
+
+        int xMax = _x0 + 3, yMax = _y0 + 3;
+
+        int x, y;
+
+        int nbJetonAligne;
+
+        Joueur dernierJoueur = dernierCoup.getJeton().getJoueur();
+
+        /* Regarde si le dernier coup est gagnant */
+        for (int d = 0; d < 4; d++) {
+            nbJetonAligne = 0;
+            x = _coupX;
+            y = _coupY;
+
+            while (x < xMax && x >= _x0 && y < yMax && y >= _y0 && _grille[x][y] != null && _grille[x][y].getJoueur() == dernierJoueur) {
+                nbJetonAligne++;
+                if (nbJetonAligne >= 3) {
+                    return true;
+                }
+                x += dir[d][0];
+                y += dir[d][1];
+            }
+
+            //regarde dans la direction opposée
+            x = _coupX;
+            y = _coupY;
+            nbJetonAligne--;
+
+            while (x < xMax && x >= _x0 && y < yMax && y >= _y0 && _grille[x][y] != null && _grille[x][y].getJoueur() == dernierJoueur) {
+                nbJetonAligne++;
+                if (nbJetonAligne >= 3) {
+                    return true;
+                }
+                x += dirOps[d][0];
+                y += dirOps[d][1];
+            }
+        }
+
+        return false;
+
+    }
+
+    @Override
+    public boolean partieGagnee() {
+        if (dernierCoup == null) {
+            return false;
+        }
+
+        if ( grilleGagnee) { // si le dernier coup a gagne une grille on regarde si on gagne sur la grande grille
+            if (caseGagnante(grille3x3, 0, 0, dernierCoup.getColonne() / 3, dernierCoup.getLigne() / 3)) {
+                
+                vainqueur = dernierCoup.getJeton().getJoueur();
+                return true;
+            }
+        }
+
+        // Compte le nombre de cases remportées par chaque joueur
+        if (isGrillePleine()) {
+            int[] nbCase = new int[2];
+            Joueur[] joueur = new Joueur[2];
+
+            for (int c = 0; c < 3; c++) {
+                for (int l = 0; l < 3; l++) {
+                    if (grille3x3[c][l] != null) {
+                        nbCase[grille3x3[c][l].getJoueur().getIdJoueur()]++;
+                        joueur[grille3x3[c][l].getJoueur().getIdJoueur()] = grille3x3[c][l].getJoueur();
+                    }
+                }
+            }
+
+            if (nbCase[0] > nbCase[1]) {
+                vainqueur = joueur[0];
+                return true;
+            }
+            if (nbCase[1] > nbCase[0]) {
+                vainqueur = joueur[1];
+                return true;
+            }
+            vainqueur = null;
+            return true;
+        }
+
+        return false;
+
+    }
+
+    @Override
+    public boolean partieNulle() {
+
+        if (vainqueur != null) {
+            return false;
+        }
+
+        if (partieGagnee()) {
+            return false;
+        }
+
+        return isGrillePleine();
+    }
+
+    @Override
+    public ArrayList<Coup> getListeCoups(Joueur _joueur) {
+
+        ArrayList<Coup> listeCoups = new ArrayList<Coup>();
+
+        if (dernierCoup != null) {
+            int x0 = (dernierCoup.getColonne() % 3) * 3;
+            int y0 = (dernierCoup.getLigne() % 3) * 3;
+            
+            for (int c = x0; c < x0 + 3; c++) {
+                for (int l = y0; l < y0 + 3; l++) {                   
+                    if ( grille3x3[(c/3)][(l/3)] != null ) continue;   // on ne peut pas jouer dans une grille gagnée
+                    
+                    if (grille9x9[c][l] == null) {
+                        listeCoups.add(new CoupTicTacToe(c, l, new Jeton(_joueur)));
+                    }
+                }
+            }
+        }
+
+        if (listeCoups.isEmpty()) {
+            for (int c = 0; c < this.getNbColonnes(); c++) {
+                for (int l = 0; l < this.getNbLignes(); l++) {
+                    if ( grille3x3[(c/3)][(l/3)] != null ) continue;   // on ne peut pas jouer dans une grille gagnée
+                    if (grille9x9[c][l] == null) {
+                        listeCoups.add(new CoupTicTacToe(c, l, new Jeton(_joueur)));
+                    }
+                }
+            }
+        }
+        return listeCoups;
+    }
+
+    @Override
+    public boolean isValide(Coup _coup) {
+        CoupTicTacToe coup = (CoupTicTacToe) _coup;
+
+        if ( grille9x9[coup.getColonne()][coup.getLigne()] != null ) return false;
+        
+        if ( dernierCoup == null ) return true;
+      
+        int x0 = (dernierCoup.getColonne() % 3 ) * 3;
+        int y0 = (dernierCoup.getLigne() % 3 ) * 3;
+                      
+        boolean grillePleine = true;
+        
+        for (int c = x0; c < x0+3 ; c++) {
+                for (int l = y0; l < y0+3 ; l++) {
+                    if ( grille3x3[c/3][l/3] != null ) continue;  // les grilles gagneés sont pleines
+                    if ( grille9x9[c][l] == null ) {
+                        grillePleine = false;
+                        break;
+                    }
+                }
+        }
+        
+        if ( grillePleine ) {           
+              return true;
+        }
+                
+      
+        return ( coup.getColonne() >= x0  && coup.getColonne() < x0+3 &&  coup.getLigne()>= y0  && coup.getLigne() < y0+3 );
+    }
+
+    @Override
+    public Coup stringToCoup(String _coup, Joueur _joueur) {
+        int colonne = Integer.valueOf(_coup.charAt(0) + "");
+        int ligne = Integer.valueOf(_coup.charAt(1) + "");
+
+        return new CoupTicTacToe(colonne, ligne, new Jeton(_joueur));
+    }
+
+    @Override
+    public void sauvegardePosition(int _index ) {
+        for (int c = 0; c < this.getNbColonnes(); c++) {
+            for (int l = 0; l < this.getNbLignes(); l++) {
+                grille9x9Sav[_index][c][l] = grille9x9[c][l];
+            }
+        }
+
+        for (int c = 0; c < 3; c++) {
+            for (int l = 0; l < 3; l++) {
+                grille3x3Sav[_index][c][l] = grille3x3[c][l];
+            }
+        }
+        dernierCoupSav = dernierCoup;
+        grilleGagneeSav = grilleGagnee;
+       
+
+    }
+
+    @Override
+    public void restaurePosition( int _index ) {
+        
+        for (int c = 0; c < this.getNbColonnes(); c++) {
+            for (int l = 0; l < this.getNbLignes(); l++) {
+                grille9x9[c][l] = grille9x9Sav[_index][c][l];
+            }
+        }
+
+        for (int c = 0; c < 3; c++) {
+            for (int l = 0; l < 3; l++) {
+                grille3x3[c][l] = grille3x3Sav[_index][c][l];
+            }
+        }
+        vainqueur = null;
+        dernierCoup = dernierCoupSav;
+        grilleGagnee = grilleGagneeSav;
+    }
+
+    private boolean isGrillePleine() {
+        for (int c = 0; c < this.getNbColonnes(); c++) {
+            for (int l = 0; l < this.getNbLignes(); l++) {
+                if ( grille3x3[c/3][l/3] != null ) continue;  // les grilles gagnées sont pleines
+                
+                if (grille9x9[c][l] == null) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public Joueur vainqueur() {
+        return vainqueur;
+    }
+
+    void trace() {
+        for (int l = 2; l >= 0; l--) {
+            for (int c = 0; c < 3; c++) {
+                System.out.print(grille3x3[c][l] + " ");
+            }
+            System.out.println("");
+        }
+    }
+
+    @Override
+    public Coup getDernierCoup() {
+       return dernierCoup;
+    }
+
+}
\ No newline at end of file

Jeton

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package tictactoecodingame;
+
+
+/**
+ *
+ * @author franck.tempet
+ */
+public class Jeton extends Piece {
+ 
+    public Jeton( Joueur _joueur ) {
+           super( _joueur );
+    }
+
+    public String toString() {
+
+           if ((getJoueur().getIdJoueur()) == 1) {
+                   return "X"; 
+           }
+           else {
+               return "O";
+           }
+    }
+   }
\ No newline at end of file

Joueur

+package tictactoecodingame;
+
+
+/**
+ * @author  Franck
+ *
+ */
+
+public abstract class Joueur {
+	private String nom;
+	private static int nbJoueur = 0;
+	private int idJoueur;
+	
+	public Joueur( String _nom ) {
+		idJoueur = nbJoueur;
+                nbJoueur++;
+                this.nom = _nom;
+	}
+	
+	public void setNom ( String _nom ) {
+		this.nom = _nom;
+	}
+	
+	public String getNom() {
+		return nom;
+	}
+
+	public int getIdJoueur() {
+		return idJoueur;
+	}
+	abstract public Coup joue( Plateau p_plateau );
+	
+	public String toString() {
+		return nom;
+	}
+}

Joueur Humain

+package tictactoecodingame;
+
+/**
+ * @author  Franck
+ *
+ */
+
+import java.io.InputStreamReader;
+import java.io.IOException;
+
+/**
+ * @author Franck
+ */
+public class JoueurHumain extends Joueur {
+
+
+    public JoueurHumain( String _joueur ) {
+        super( _joueur );
+    }
+
+    public Coup joue(Plateau _plateau) {
+        InputStreamReader clavier = new InputStreamReader(System.in);
+        char buffer[] = new char[10];
+        
+        String monCoup = null;
+
+        // Demande au joueur de saisir son Coup
+        System.out.println("Votre coup : ");
+
+        try {
+            int nbCar = clavier.read(buffer, 0, 5);
+            monCoup = new String(buffer, 0, nbCar-1);
+
+            return _plateau.stringToCoup(monCoup, this);
+            
+        } catch (IOException e) {
+            return null;
+        }
+
+    }
+}

JoueurOrdi

+package tictactoecodingame;
+
+/**
+ * @author Franck
+ */
+public class JoueurOrdi extends Joueur {
+    boolean ponder; // Si vrai l'ordinateur réfléchi pendant la reflexion de son adversaire
+    
+    AlgoRecherche algoRecherche;
+    
+    public JoueurOrdi(String _nom) {
+        super(_nom);
+        ponder = false;
+    }
+    
+    public JoueurOrdi( String _nom , AlgoRecherche _algo , boolean _ponder ) {
+        super( _nom );
+        algoRecherche = _algo;
+        ponder = _ponder;
+    }
+
+    public JoueurOrdi( String _nom , AlgoRecherche _algo  ) {
+        this( _nom , _algo , false );
+    }
+
+    public AlgoRecherche getAlgoRecherche() {
+        return algoRecherche;
+    }
+
+    public void setAlgoRecherche(AlgoRecherche _algoRecherche) {
+        algoRecherche = _algoRecherche;
+    }
+    
+
+    public Coup joue(Plateau _plateau  ) {
+        Coup coupOrdi;
+
+        coupOrdi = algoRecherche.meilleurCoup(_plateau , this , ponder);
+       
+        return coupOrdi;
+    }
+}

Ordi qui joue contre ordi

+public class Ordi {
+    public static void main(String args[]) {
+        
+        JoueurOrdi joueurOrdi1 = new JoueurOrdi("Ordi1");     
+        JoueurOrdi joueurOrdi2 = new JoueurOrdi("Ordi2");
+       
+        
+        // Remplacer ici l'algorithme aléatoire par votre algorithme. 
+        // Créer une nouvelle classe qui hérite de la class AlgoRecherche
+        AlgoRechercheAleatoire alea  = new AlgoRechercheAleatoire( );   // L'ordinateur joue au hasard
+        joueurOrdi1.setAlgoRecherche(alea);
+         AlgoRechercheAleatoire alea2  = new AlgoRechercheAleatoire( );   // L'ordinateur joue au hasard
+        joueurOrdi2.setAlgoRecherche(alea2);
+             
+        GrilleTicTacToe3x3 grille = new GrilleTicTacToe3x3();
+         
+        Arbitre a = new Arbitre(grille, joueurOrdi1 , joueurOrdi2 );
+       
+        a.startNewGame(true); 
\ No newline at end of file

Plateau

+package tictactoecodingame;
+
+import java.util.ArrayList;
+
+/**
+ * @author Franck
+ *
+ * Classe générique pour les jeux de plateau à 2 joueurs ( une grille de puissance 4 , un échiquier , .. )
+ */
+public abstract class Plateau  {
+ 
+    abstract public void init();			// Initialise le plateau pour le démarrage d'une nouvelle partie.
+
+    abstract public Piece getPiece(Case _case);  	// Retourne la pièce presente sur la case _case
+
+    abstract public void joueCoup(Coup _coup);		// Joue le coup _coup sur le plateau
+
+    abstract public void annuleDernierCoup();		// Annule le dernier coup joué
+
+    abstract public int getNbColonnes();		// Retourne le nombre de colonnes du plateau
+
+    abstract public int getNbLignes();			// Retourne le nombre de lignes du plateau
+
+    abstract public boolean partieTerminee();		// Vrai si la partie est terminee ( soit un gagnant soit un match nulle )
+
+    abstract public boolean partieGagnee();		// Vrai si le dernier joueur  a gagné la partie
+    
+    abstract public boolean partieNulle();              // Vrai si la partie est nulle
+    
+    abstract public Joueur vainqueur();                  // Retourne le joueur qui a gagné la partie
+
+    abstract public ArrayList<Coup> getListeCoups(Joueur _joueur); 	// Retourne la liste des coups possibles.
+
+    abstract public boolean isValide(Coup _coup);		// Retourne Vrai si le coup est valide.
+
+    abstract public Coup stringToCoup(String _coup, Joueur _joueur);  // Convertion d'une chaine de caractères en un Coup
+    
+    abstract public void sauvegardePosition(int _index);              // Sauvegarde la position courante dans l'indice _index
+    
+    abstract public void restaurePosition(int _index);                 // restaure la  position sauvegarde en indice _index
+    
+    abstract public Coup getDernierCoup();                  // Retourne le dernierCoup joue
+    
+
+    public String toString() {						// Donne une représentation du plateau sous forme d'une chaine de caractères
+        Piece piece;
+        String chainePlateau = new String();
+
+        for (int ligne = getNbLignes() - 1; ligne >= 0; ligne--) {
+            chainePlateau += ligne;
+            for (int colonne = 0; colonne < getNbColonnes(); colonne++) {
+                piece = getPiece(new Case(colonne, ligne));
+                if (piece == null) {
+                    chainePlateau += "|   ";
+                } else {
+                    chainePlateau += "|" + piece + "  ";
+                }
+            }
+            chainePlateau += "|\n  ";
+            for (int colonne = 0; colonne < getNbColonnes(); colonne++) {
+                chainePlateau += "____";
+            }
+            chainePlateau += "\n";
+        }
+
+        for (int colonne = 0; colonne < getNbColonnes(); colonne++) 
+            chainePlateau += "  "+ colonne + " ";
+        return chainePlateau;
+    }          
+}

Player class

+package tictactoecodingame;
+
+/**
+ *
+ * @author franck
+ */
+
+    /*--------------------------------------------------------*/
+    /*                 Version jeu en local                   */
+    /*--------------------------------------------------------*/
+public class Player {
+
+    public static void main(String args[]) {
+        
+        JoueurHumain humain = new JoueurHumain("Humain");     
+        JoueurOrdi joueurOrdi = new JoueurOrdi("Ordi");
+       
+        
+        // Remplacer ici l'algorithme aléatoire par votre algorithme. 
+        // Créer une nouvelle classe qui hérite de la class AlgoRecherche
+        AlgoRechercheAleatoire alea  = new AlgoRechercheAleatoire( );   // L'ordinateur joue au hasard
+        joueurOrdi.setAlgoRecherche(alea);                              
+             
+        GrilleTicTacToe3x3 grille = new GrilleTicTacToe3x3();
+         
+        Arbitre a = new Arbitre(grille, joueurOrdi , humain );
+       
+        a.startNewGame(true);    // Demarre une partie en affichant la grille du jeu
+       
+       // Pour lancer un tournooi de 100 parties en affichant la grille du jeu
+        //a.startTournament(1000 , false);
+        
+    }
+}
+
+    /*--------------------------------------------------------*/
+    /*                 Version Codin game                     */
+    /*--------------------------------------------------------*/
+
+    /*
+    import java.util.Scanner;
+
+
+
+    class Player {
+
+       public static void main(String args[]) {
+
+            Scanner in = new Scanner(System.in);
+
+            CoupTicTacToe3x3 coup;
+            JoueurHumain adversaire = new JoueurHumain("Adversaire");
+            JoueurOrdi joueurOrdi = new JoueurOrdi("Ordi");
+
+            AlgoRechercheAleatoire alea  = new AlgoRechercheAleatoire( );   // L'ordinateur joue au hasard
+            joueurOrdi.setAlgoRecherche(alea);
+
+            GrilleTicTacToe3x3 grille = new GrilleTicTacToe3x3();
+            grille.init();
+
+
+            while (true) {
+                int opponentRow = in.nextInt();
+                int opponentCol = in.nextInt();
+                int validActionCount = in.nextInt();
+                for (int i = 0; i < validActionCount; i++) {
+                    int row = in.nextInt();
+                    int col = in.nextInt();
+                }
+                if ( opponentCol != -1  ) {
+                    coup = new CoupTicTacToe3x3(opponentCol, opponentRow, new Jeton(adversaire));
+                    grille.joueCoup(coup);
+                }
+
+                coup = (CoupTicTacToe3x3) joueurOrdi.joue(grille);
+                grille.joueCoup(coup);
+                System.out.println(coup.getLigne() + " " + coup.getColonne() ); 
+                System.out.flush();
+            }
+       }
+    
+}
+*/
\ No newline at end of file

pieces

+package tictactoecodingame;
+
+
+/**
+ * @author Franck
+ */
+
+public abstract class Piece {
+  private Joueur joueur;
+
+  
+   
+  public Piece( Joueur _joueur ) {
+  	this.joueur = _joueur;
+  }
+  
+  public void setJoueur(Joueur _joueur) {
+	joueur = _joueur;
+  }
+  
+  
+
+  public Joueur getJoueur() {
+  	return joueur;
+  }
+  
+  abstract public String toString();
+}