Pour upload

build.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!-- You may freely edit this file. See commented blocks below for -->
+<!-- some examples of how to customize the build. -->
+<!-- (If you delete it and reopen the project it will be recreated.) -->
+<!-- By default, only the Clean and Build commands use this build script. -->
+<!-- Commands such as Run, Debug, and Test only use this build script if -->
+<!-- the Compile on Save feature is turned off for the project. -->
+<!-- You can turn off the Compile on Save (or Deploy on Save) setting -->
+<!-- in the project's Project Properties dialog box.-->
+<project name="TicTacToeCodingame" default="default" basedir=".">
+    <description>Builds, tests, and runs the project TicTacToeCodingame.</description>
+    <import file="nbproject/build-impl.xml"/>
+    <!--
+
+    There exist several targets which are by default empty and which can be 
+    used for execution of your tasks. These targets are usually executed 
+    before and after some main targets. They are: 
+
+      -pre-init:                 called before initialization of project properties
+      -post-init:                called after initialization of project properties
+      -pre-compile:              called before javac compilation
+      -post-compile:             called after javac compilation
+      -pre-compile-single:       called before javac compilation of single file
+      -post-compile-single:      called after javac compilation of single file
+      -pre-compile-test:         called before javac compilation of JUnit tests
+      -post-compile-test:        called after javac compilation of JUnit tests
+      -pre-compile-test-single:  called before javac compilation of single JUnit test
+      -post-compile-test-single: called after javac compilation of single JUunit test
+      -pre-jar:                  called before JAR building
+      -post-jar:                 called after JAR building
+      -post-clean:               called after cleaning build products
+
+    (Targets beginning with '-' are not intended to be called on their own.)
+
+    Example of inserting an obfuscator after compilation could look like this:
+
+        <target name="-post-compile">
+            <obfuscate>
+                <fileset dir="${build.classes.dir}"/>
+            </obfuscate>
+        </target>
+
+    For list of available properties check the imported 
+    nbproject/build-impl.xml file. 
+
+
+    Another way to customize the build is by overriding existing main targets.
+    The targets of interest are: 
+
+      -init-macrodef-javac:     defines macro for javac compilation
+      -init-macrodef-junit:     defines macro for junit execution
+      -init-macrodef-debug:     defines macro for class debugging
+      -init-macrodef-java:      defines macro for class execution
+      -do-jar:                  JAR building
+      run:                      execution of project 
+      -javadoc-build:           Javadoc generation
+      test-report:              JUnit report generation
+
+    An example of overriding the target for project execution could look like this:
+
+        <target name="run" depends="TicTacToeCodingame-impl.jar">
+            <exec dir="bin" executable="launcher.exe">
+                <arg file="${dist.jar}"/>
+            </exec>
+        </target>
+
+    Notice that the overridden target depends on the jar target and not only on 
+    the compile target as the regular run target does. Again, for a list of available 
+    properties which you can use, check the target you are overriding in the
+    nbproject/build-impl.xml file. 
+
+    -->
+</project>

manifest.mf

+Manifest-Version: 1.0
+X-COMMENT: Main-Class will be added automatically by build
+

nbproject/genfiles.properties

+build.xml.data.CRC32=662cc432
+build.xml.script.CRC32=54ced37f
+build.xml.stylesheet.CRC32=8064a381@1.80.1.48
+# This file is used by a NetBeans-based IDE to track changes in generated files such as build-impl.xml.
+# Do not edit this file. You may delete it but then the IDE will never regenerate such files for you.
+nbproject/build-impl.xml.data.CRC32=662cc432
+nbproject/build-impl.xml.script.CRC32=823cde1a
+nbproject/build-impl.xml.stylesheet.CRC32=830a3534@1.80.1.48

nbproject/project.properties

+annotation.processing.enabled=true
+annotation.processing.enabled.in.editor=false
+annotation.processing.processors.list=
+annotation.processing.run.all.processors=true
+annotation.processing.source.output=${build.generated.sources.dir}/ap-source-output
+application.title=TicTacToeCodingame
+application.vendor=franck.tempet
+build.classes.dir=${build.dir}/classes
+build.classes.excludes=**/*.java,**/*.form
+# This directory is removed when the project is cleaned:
+build.dir=build
+build.generated.dir=${build.dir}/generated
+build.generated.sources.dir=${build.dir}/generated-sources
+# Only compile against the classpath explicitly listed here:
+build.sysclasspath=ignore
+build.test.classes.dir=${build.dir}/test/classes
+build.test.results.dir=${build.dir}/test/results
+# Uncomment to specify the preferred debugger connection transport:
+#debug.transport=dt_socket
+debug.classpath=\
+    ${run.classpath}
+debug.test.classpath=\
+    ${run.test.classpath}
+# Files in build.classes.dir which should be excluded from distribution jar
+dist.archive.excludes=
+# This directory is removed when the project is cleaned:
+dist.dir=dist
+dist.jar=${dist.dir}/TicTacToeCodingame.jar
+dist.javadoc.dir=${dist.dir}/javadoc
+endorsed.classpath=
+excludes=
+includes=**
+jar.compress=false
+javac.classpath=
+# Space-separated list of extra javac options
+javac.compilerargs=
+javac.deprecation=false
+javac.external.vm=true
+javac.processorpath=\
+    ${javac.classpath}
+javac.source=1.8
+javac.target=1.8
+javac.test.classpath=\
+    ${javac.classpath}:\
+    ${build.classes.dir}
+javac.test.processorpath=\
+    ${javac.test.classpath}
+javadoc.additionalparam=
+javadoc.author=false
+javadoc.encoding=${source.encoding}
+javadoc.noindex=false
+javadoc.nonavbar=false
+javadoc.notree=false
+javadoc.private=false
+javadoc.splitindex=true
+javadoc.use=true
+javadoc.version=false
+javadoc.windowtitle=
+main.class=tictactoecodingame.Player
+manifest.file=manifest.mf
+meta.inf.dir=${src.dir}/META-INF
+mkdist.disabled=false
+platform.active=default_platform
+run.classpath=\
+    ${javac.classpath}:\
+    ${build.classes.dir}
+# Space-separated list of JVM arguments used when running the project.
+# You may also define separate properties like run-sys-prop.name=value instead of -Dname=value.
+# To set system properties for unit tests define test-sys-prop.name=value:
+run.jvmargs=
+run.test.classpath=\
+    ${javac.test.classpath}:\
+    ${build.test.classes.dir}
+source.encoding=UTF-8
+src.dir=src
+test.src.dir=test

nbproject/project.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://www.netbeans.org/ns/project/1">
+    <type>org.netbeans.modules.java.j2seproject</type>
+    <configuration>
+        <data xmlns="http://www.netbeans.org/ns/j2se-project/3">
+            <name>TicTacToeCodingame</name>
+            <source-roots>
+                <root id="src.dir"/>
+            </source-roots>
+            <test-roots>
+                <root id="test.src.dir"/>
+            </test-roots>
+        </data>
+    </configuration>
+</project>

readme.md

+# Algorithme MinMax et Monte Carlo
+# Objectif
+
+Votre objectif sera d’implémenter l’algorithme MinMax et l’algorithme MonteCarlo Tree Search sur le jeu TicTacToe présent sur la plateforme [Codingame](https://www.codingame.com/start). Vous partirez d’un code Java existant afin de vous focaliser essentiellement sur ces algorithmes. 
+
+# Récupérer le code Java
+
+Les sources sont sur [bitbucket](www.bitbucket.org). L’adresse du repository est la suivante :
+
+```bash
+git clone https://francktempet@bitbucket.org/Num-ILD/tictactoe.git
+```
+
+## Quelques explications sur le code
+
+### La classe Player
+
+Cette classe contient la méthode **main** du programme. Elle crée un joueur «*humain*» ainsi qu’un joueur «*Ordinateur*». L’ordinateur joue les coups de manière aléatoire.   
+
+### La classe Plateau
+
+Regarder les méthodes contenues dans cette classe ainsi que les commentaires associés. Cette classe est une classe abstraite qui liste les méthodes nécessaires à la manipulation d’un jeu de plateau à deux joueurs. Vous aurez besoin essentiellement des méthodes suivantes :
+\newpage
+
+>- partieTerminee()
+>- getListeCoups()
+>- vainqueur()
+>- joueCoup()
+>- sauvegardePosition()
+>- restaurePosition()
+>- annuleDernierCoup()
+>- ….
+
+
+### La classe GrilleTicTacToe3x3
+
+Cette classe représente la grille du jeu TicTacToe de dimension 3x3. Cette classe hérite de Plateau, elle implémente donc toutes les méthodes abstraites présentes dans la classe Plateau. C’est cette grille que vous utiliserez dans un premier temps.
+
+### La classe GrilleTicTacToe9x9
+
+Cette classe représente la grille du jeu TicTacToe de dimension 9x9. Cette classe hérite de Plateau, elle implémente donc toutes les méthodes abstraites présentes dans la classe Plateau. Cette grille sera utilisée lorsque vous aurez franchi le premier niveau sur Codingame.
+
+# Implémenter l'algorithme
+
+Regardez en détail le contenu de la classe **Player**. La création de l’IA ( *joueurOrdi* ) nécessite  d’appeler la méthode **setAlgoRecherche** en lui passant en paramètre une instance d’une classe qui implémente l’interface **AlgoRecherche**. Dans notre cas c'est la classe **AlgoRechercheAleatoire** qui implémente cette interface. Elle implémente donc la méthode suivante :
+
+```java
+public Coup meilleurCoup(Plateau _plateau, Joueur _joueur, boolean _ponder)
+```
+
+On doit passer à cette méthode le plateau du jeu ( *ici GrilleTicTacToe3x3* ) , le joueur à qui c'est le tour de jouer et un dernier paramètre qui indique si l'ordinateur peut analyser la position lorsque c'est à son adversaire de jouer.
+
+L'algorithme aléatoire récupère la liste des coups possibles à partir de la position courante et en choisit un au hasard.
+
+```java
+Random rnd;
+
+public Coup meilleurCoup(Plateau _plateau, Joueur _joueur, boolean _ponder) {    
+
+    ArrayList<Coup> coups = _plateau.getListeCoups(_joueur);   
+    return coups.get(rnd.nextInt( coups.size()));
+}
+```
+
+
+Vous devrez donc écrire soit une classe AlgoMinMax soit une classe AlgoMCTS. Ces deux classes devront implémenter également l’interface *AlgoRecherche* ce qui revient à écrire la méthode *meilleurCoup*.
+
+
+
+# Tester son IA en local
+
+La classe Player actuelle vous permet de jouer contre votre IA. Vous pouvez  modifier facilement cette classe afin de faire jouer deux IA l’une contre l’autre.
+
+# Tester son IA sur Codingame
+
+Afin de tester votre IA sur *Codingame*, il vous faudra modifier le contenu de la classe **Player** pour être compatible avec le mode de fonctionnement de la plateforme, à savoir récupérer les données en entrée ( code déjà fourni par le site ) et retourner sur la sortie standard votre coup. La classe **Arbitre** ne sera plus nécessaire puisque se sera la plateforme Codingame qui fera office d'arbitre.  La classe **Player** contient également la version pour le bon fonctionnement de votre IA sur Codingame. Il suffit de dé-commenter la partie *Codingame* et commenter le jeu en local
+
+
+Pour générer un seul fichier à partir de l’ensemble de vos classes  vous utiliserez le **builder.jar** en effectuant les commandes suivantes.
+
+Lancez l’invite de commande **cmd.exe** et  tapez les commandes suivantes :
+```bash 
+# C est la lettre du disque dur où se trouve votre projet 
+C: 
+
+# Se positionner dans le répertoire src du projet
+# exemple cd c:\netbean\TicTacToeCodingame\src
+cd <nom_du_répertoire source>  
+
+# Lancer le builder.jar
+# Cette commande va générer un fichier Player.java dans le répertoire courant.
+# C’est ce fichier qu’il faudra poster sur codingame.
+
+java –jar builder.jar .\tictactoecodingame\Player.java 
+```
+# Amélioration des algorithmes
+
+Lorsque vos algorithmes MinMax et MCTS seront implémentés et fonctionneront correctement, votre objectif sera de rechercher les possibilités d'améliorations de ces algorithmes. Vous indiquerez le résultat de vos recherches et les implémenterez afin d'améliorer votre IA.
+
+
+

src/tictactoecodingame/AlgoRecherche.java

+package tictactoecodingame;
+
+/**
+ * @author  Franck
+ *
+ */
+
+public abstract class AlgoRecherche {
+
+
+        /**
+         * 
+         * @param _plateau  Grille du jeu
+         * @param _joueur   c'est à ce joueur de jouer
+         * @param _ponder  vrai si l'ordi analyse la position pendant le temps de reflexion de l'adversaire
+         * @return 
+         */
+	abstract public Coup meilleurCoup( Plateau _plateau , Joueur _joueur , boolean _ponder );
+	
+
+}

src/tictactoecodingame/AlgoRechercheAleatoire.java

+/*
+ * 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()));
+    }
+
+   
+    
+}

src/tictactoecodingame/Arbitre.java

+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;
+    }
+}

src/tictactoecodingame/Case.java

+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;
+    }
+      
+}

src/tictactoecodingame/Coup.java

+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();
+    
+}

src/tictactoecodingame/CoupTicTacToe.java

+/*
+ * 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;
+    }
+    
+
+}

src/tictactoecodingame/GrilleTicTacToe3x3.java

+/*
+ * 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;
+    }
+
+}

src/tictactoecodingame/Jeton.java

+/*
+ * 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

src/tictactoecodingame/Joueur.java

+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;
+	}
+}

src/tictactoecodingame/JoueurHumain.java

+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;
+        }
+
+    }
+}

src/tictactoecodingame/JoueurOrdi.java

+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;
+    }
+}

src/tictactoecodingame/Piece.java

+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();
+}

src/tictactoecodingame/Plateau.java

+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;
+    }          
+}

src/tictactoecodingame/Player.java

+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