Merge remote-tracking branch 'origin/RegionNode' into main

# Conflicts:
#	src/project/Bot.java
#	src/project/Case.java
#	src/project/Joueur.java
#	src/project/Main.java
#	src/project/Menu.java
#	src/project/Partie.java
#	src/project/PetiteRegion.java
#	src/project/Plateau.java
#	src/project/Quadtree.java
#	src/project/Region.java

.gitignore

 /bin/
+.html
+.js
+.css
+.iml
\ No newline at end of file

src/project/Bot.java

@@ -8,7 +8,18 @@ public class Bot extends Joueur{
 
 	@Override
 	public Case jouer() {
-		return JouerIATemeraire();
+		switch (this.partie.getRegle().regleId()){
+			case 0 :
+				return jouerGlouton();
+			case 1 :
+				return JouerIATemeraire();
+		}
+		System.out.println("erreur, le bot n'a pas joué de coup : les règles en vigueur ne sont ni Brave, ni Téméraire");
+		return null;
+	}
+
+	public Case jouerGlouton(){
+		return partie.getPlateau().getPilePriorite().meilleurCoup();
 	}
 
 	public Case JouerIATemeraire() {

src/project/Case.java

 package project;
 
+/**
+ * Classe de représentation de case du plateau de jeu
+ */
 public class Case{
 
 	protected int ligne;
@@ -8,12 +11,15 @@ public class Case{
 	private PetiteRegion pregion;
 	private boolean acquise;
 	private Couleur couleur;
-	
+
+	private int valeur;
+
 	public Case(int i, int j) {
 		this.ligne = i;
 		this.colonne = j;
 		this.acquise = false;
 		this.setCouleur(Couleur.A);
+		this.valeur = 1;
 	}
 
 	public Case(int i, int j, PetiteRegion pregion) {
@@ -22,45 +28,96 @@ public class Case{
 		this.acquise = false;
 		this.setCouleur(Couleur.A);
 		this.pregion = pregion;
+		this.valeur = 1;
+	}
+
+	/**
+	 * Colorie une case selon les règles de jeu Brave
+	 * @param couleur la couleur avec laquelle on veut colorier la case
+	 */
+	public void colorierBrave(Couleur couleur) {
+		this.setCouleur(couleur);
+	}
+
+	/**
+	 * Colorie une case selon les règles de jeu Téméraire
+	 * @param couleur la couleur avec laquelle on veut colorier la case
+	 */
+	public void colorierTemeraire(Couleur couleur) {
+		this.setCouleur(couleur);
+
+		this.getPregion().updateAcquise();
+		this.getPregion().updateColoriee();
 	}
-	
+
+
+	//GETTERS SETTERS
+
+	/**
+	 * @return Vrai si cette case est acquise, faux sinon
+	 */
 	public boolean estAcquise() {
 		return this.acquise;
 	}
 
+	/**
+	 * @return Vrai si la couleur de la case n'est pas blanche, faux sinon
+	 */
 	public boolean caseColoriee(){
 		return this.couleur != Couleur.A;
 	}
 
+	/**
+	 * @return La couleur de cette case
+	 */
 	public Couleur getCouleur() {
 		return couleur;
 	}
 
+	/**
+	 * Met à jour l'attribut couleur de la case
+	 * @param couleur la couleur avec laquelle on veut colorier la case
+	 */
 	public void setCouleur(Couleur couleur) {
 		this.couleur = couleur;
 	}
-	
+
+	/**
+	 * Rend l'attribut acquise de la case vrai
+	 */
 	public void acquerir() {
 		this.acquise = true;
 	}
 
+	/**
+	 * @return La petite région contenant cette case
+	 */
 	public PetiteRegion getPregion() {
 		return pregion;
 	}
 
+	/**
+	 * Met à jour l'attribut pregion de cette case
+	 * @param pregion la petite région dans laquelle se situe cette case
+	 */
 	public void setPregion(PetiteRegion pregion) {
 		this.pregion = pregion;
 	}
 
-	public void colorierBrave(Couleur couleur) {
-		this.setCouleur(couleur);
-	}
 
-	public void colorierTemeraire(Couleur couleur) {
-		this.setCouleur(couleur);
+	/**
+	 * @return Le nombre de points que rapporterait la case au joueur bleu s'il la jouait
+	 */
+	public int getValeur() {
+		return this.valeur;
+	}
 
-		this.getPregion().updateAcquise();
-		this.getPregion().updateColoriee();
+	/**
+	 * Met à jour la valeur de la case
+	 * @param valeur la nouvelle valeur de la case
+	 */
+	public void setValeur(int valeur) {
+		this.valeur = valeur;
 	}
 
 }
\ No newline at end of file

src/project/Couleur.java

 package project;
 
 public enum Couleur {
-	B,
-	R,
-	A
+	B,//0
+	R,//1
+	A//2
 }

src/project/Joueur.java

@@ -2,6 +2,10 @@ package project;
 
 import java.util.Scanner;
 
+/**
+ * Classe joueur, implémente les actions d'un joueur pendant son tour
+ * @author Erwan
+ */
 public class Joueur {
 	Partie partie;
 	Couleur couleur;
@@ -11,6 +15,10 @@ public class Joueur {
 		this.couleur = couleur;
 	}
 
+	/**
+	 * Permet à un joueur de choisir une case à jouer
+	 * @return La case choisi par le joueur
+	 */
 	public Case jouer(){
 		Scanner input = new Scanner(System.in);
 		System.out.println("Ligne de la case recherchée ? ");
@@ -32,4 +40,32 @@ public class Joueur {
 
 		return partie.getPlateau().getMatrice()[i][j];
 	}
+
+	/**
+	 * Permet à un joueur de choisir une case à évaluer
+	 * @return La case choisi par le joueur
+	 */
+	public Case evaluer(){
+		Scanner input = new Scanner(System.in);
+		System.out.println("Ligne de la case recherchée ? ");
+		int i = input.nextInt();
+
+		System.out.println("Colonne de la case recherchée ? ");
+		int j = input.nextInt();
+
+
+		while (i >= partie.getPlateau().getLongueur() || j >= partie.getPlateau().getLongueur() || i < 0 || j < 0 || partie.getPlateau().getMatrice()[i][j].getCouleur() != Couleur.A){
+			System.out.println("Erreur! ");
+
+			System.out.println("Ligne de la case recherchée ? ");
+			i = input.nextInt();
+
+			System.out.println("Colonne de la case recherchée ? ");
+			j = input.nextInt();
+		}
+
+		System.out.println(partie.evaluerCase(partie.getPlateau().getMatrice()[i][j], this));
+
+		return partie.getPlateau().getMatrice()[i][j];
+	}
 }

src/project/Main.java

@@ -5,14 +5,14 @@ import java.util.Scanner;
 
 public class Main {
 	public static void main(String[] args) {
-		/*Menu menu = new Menu();
 
-		while(true){
-			menu.choisirParamètres();
-		}*/
+		Menu menu = new Menu();
+		menu.choisirParametres();
+		Partie partie = menu.creerPartie();
 
+		partie.demarrerPartie();
 
-		Partie partie = new Partie();
+		/*Partie partie = new Partie();
 
 		Scanner console = new Scanner(System.in);
 
@@ -20,7 +20,7 @@ public class Main {
 
 		int rule = console.nextInt();
 
-		partie.setPlateau(new Plateau(6));
+		partie.setPlateau(new Plateau(24));
 		
 		if(rule == 0){
 			partie.setRegle(new Brave());
@@ -28,43 +28,24 @@ public class Main {
 
 		if(rule == 1){
 			partie.setRegle(new Temeraire());
-			partie.getPlateau().initalisationQuadtreeEtMatrice();
+			partie.getPlateau().initalisationQuadtreeDepuisMatrice();
 		}
 
 		partie.setJoueur1(new Joueur(Couleur.R, partie));
 		partie.setJoueur2(new Joueur(Couleur.B, partie));
 
-		/*partie.jouerCase(partie.getPlateau().getMatrice()[0][0], partie.joueur1);
-		partie.jouerCase(partie.getPlateau().getMatrice()[1][1], partie.joueur2);
-		
-		System.out.println(partie.evaluerCase(1, 0, partie.joueur1));*/
-		
-		partie.demarrerPartie();
-
-		/*Plateau plateau = new Plateau(24);
-		
-		plateau.afficherPlateau();
-
-		Joueur j1 = new Joueur(Couleur.B, null);
-
-		System.out.println(plateau.getArbrePlateau().getRoot().getV1().getV2().getRegionSuperieure());
-		Case temp = plateau.getArbrePlateau().rechercheCase(1,1);
-		
-		Case[] cases = plateau.voisins(temp);
-
-		plateau.colorierCase(plateau.getArbrePlateau().rechercheCase(0,20), Couleur.R);
-
-		for(int i = 0; i < cases.length-1; i++) {
-			System.out.println(i);
-			plateau.colorierCase(cases[i], j1.couleur);
-		}
-
-		plateau.colorierCasesTemeraire(plateau.getArbrePlateau().rechercheCase(2,2), Couleur.R);
-
-		int score = plateau.calculeScoreNaif();
-
-		plateau.afficherPlateau();
+		for(int i = 0; i < 24; i++){
+			for(int j = 0; j < 24; j++){
+				System.out.println("eval : " + partie.evaluerCase(partie.getPlateau().getMatrice()[j][i], (i+j)%2 == 0? partie.joueur1 : partie.joueur2));
+				partie.jouerCase(partie.getPlateau().getMatrice()[j][i], (i+j)%2 == 0? partie.joueur1 : partie.joueur2);
+				partie.setScore(partie.calculScore());
+				System.out.println("score : " + partie.getScore());
+				partie.getPlateau().afficherPlateau();
+				System.out.println("//-----------------------------------------------");
+			}
+			partie.getPlateau().afficherPlateau();
+		}*/
 
-		System.out.println(score);*/
+		//partie.demarrerPartie();
 	}
 }

src/project/Menu.java

@@ -3,10 +3,21 @@ package project;
 import java.util.Scanner;
 
 public class Menu {
+    int inputInt;
+    String initPlateau;
+    int taillePlateau;
+    int regleId;
+    int strategieId;
+    boolean scoreAffiche;
+    boolean peutEvaluer;
+
     public Menu(){
 
     }
 
+    /**
+     * Permet à l'utilisateur de choisir les paramètres d'une partie à créer
+     */
     public void choisirParametres(){
 
         Scanner console = new Scanner(System.in);
@@ -26,6 +37,7 @@ public class Menu {
 
         String initPlateau = inputString;
 
+        int taillePlateau = 0;
 
         if(initPlateau.equals("vide")){
             //Taille du plateau
@@ -37,11 +49,7 @@ public class Menu {
                 inputInt = console.nextInt();
             }
 
-            int taillePlateau = inputInt;
-        } else {
-            //Input de fichier
-            //TODO implémentation de l'initialisation par fichier
-
+            taillePlateau = (int) Math.pow(2,inputInt) * 3;
         }
 
         //Séléction des règles
@@ -75,11 +83,11 @@ public class Menu {
         }
 
         //Séléction de l'affichage du score
-        System.out.println("Afficher le score en permanence? : oui / non");
+        System.out.println("1 Afficher le score en permanence? : oui / non");
+        inputString = console.nextLine();
         inputString = console.nextLine();
-
         while(!inputString.equals("oui") && !inputString.equals("non")){
-            System.out.println("Erreur, choisissez parmi ces deux options : oui / non");
+            System.out.println("1 Erreur, choisissez parmi ces deux options : oui / non");
             inputString = console.nextLine();
         }
 
@@ -87,16 +95,53 @@ public class Menu {
 
 
         //Séléction de l'accès a l'évaluation de cases
-        System.out.println("Possibilité d'évaluer les cases? : oui / non");
+        System.out.println("2 Possibilité d'évaluer les cases? : oui / non");
         inputString = console.nextLine();
 
         while(!inputString.equals("oui") && !inputString.equals("non")){
-            System.out.println("Erreur, choisissez parmi ces deux options : oui / non");
+            System.out.println("2 Erreur, choisissez parmi ces deux options : oui / non");
             inputString = console.nextLine();
         }
 
         boolean peutEvaluer = inputString.equals("oui");
 
+        this.initPlateau = initPlateau;
+        this.taillePlateau = taillePlateau;
+        this.regleId = regleId;
+        this.strategieId = strategieId;
+        this.scoreAffiche = scoreAffiche;
+        this.peutEvaluer = peutEvaluer;
+    }
+
+    /**
+     * Crée une partie à partir des options sélectionnées dans choisirParametres()
+     * @return la partie créée
+     */
+    public Partie creerPartie(){
+        Partie partie = new Partie();
+        partie.setRegle(this.regleId == 0? new Brave(): new Temeraire());
+        partie.setJoueur1(new Joueur(Couleur.R, partie));
+        partie.setJoueur2(new Bot(Couleur.B, partie));
+        partie.setGlouton(this.strategieId == 0);
+
+        if(initPlateau.equals("fichier")){
+            Scanner scanner = new Scanner(System.in);
+
+            System.out.println("Rentrez le chemin absolu du fichier que vous souhaitez utiliser pour initialiser le plateau");
+            String path = scanner.nextLine();
 
+            partie.setPlateau(new Plateau(partie, path));
+        }else{
+            partie.setPlateau(new Plateau(taillePlateau, partie));
+            if(this.regleId == 1){partie.getPlateau().initalisationQuadtreeDepuisMatrice();}
+        }
+
+
+        partie.setPeutEvaluer(this.peutEvaluer);
+        partie.setScoreAffiche(this.scoreAffiche);
+        return partie;
     }
+
+
+
 }

src/project/Partie.java

 package project;
 
+import java.util.Scanner;
+
 public class Partie {
 	Plateau plateau;
 	Joueur joueur1;
 	Joueur joueur2;
 	Regle regle;
+	boolean glouton;
 	int score;
+	boolean peutEvaluer;
+	boolean scoreAffiche;
+
 
 	public Partie() {
 		this.plateau = null;
 		this.joueur1 = null;
 		this.joueur2 = null;
 		this.regle = null;
+		this.peutEvaluer = false;
+		this.scoreAffiche = false;
 		this.score = 0;
 	}
 
+	/**
+	 * Lance le premier tour d'une partie
+	 */
 	public void demarrerPartie() {
 		//TODO : implementer
+		this.setScore(0);
+
+		this.plateau.afficherPlateau();
+
+		Joueur joueurActif = joueur1;
+
+		while(!this.estFini()){
+			tour(joueurActif);
+
+			if(joueur1.equals(joueurActif)){
+				joueurActif = joueur2;
+
+			} else{
+				joueurActif = joueur1;
+
+			}
+		}
 
-		tour(joueur1);
+		System.out.println("//--------------------------------------------------------");
+		this.getPlateau().afficherPlateau();
+		finirPartie();
 	}
 
+	/**
+	 * Effectue un tour
+	 */
 	public void tour(Joueur joueur){
 		System.out.println("Au tour de : " + joueur.couleur);
-		if(!this.estFini()){
-			Case caseJouee = joueur.jouer();
-			jouerCase(caseJouee, joueur);
 
-			this.getPlateau().afficherPlateau();
+		if(scoreAffiche){
+			/*score = this.calculScore();
+			System.out.println("Score :" + this.calculScore());*/
 
-			if(joueur1.equals(joueur)){
-				tour(joueur2);
-			} else{
-				tour(joueur1);
+			//UNE FOIS QUE J AURAIS IMPLEMENTE L UPDATE DU SCORE EN TEMPS, REEL, UTILISER LES METHODES CI DESSOUS
+
+			System.out.println("Score : " + this.score);
+
+		}
+
+		if(peutEvaluer){//IMPLEMENTER TOUS LES CHECKS DE PRECONDITIONS DES ENTREES
+			boolean evaluer = true;
+
+			Scanner input = new Scanner(System.in);
+
+			Case caseEvaluee;
+
+			System.out.println("Evaluer ? oui / non");
+			String answer = input.nextLine();
+
+			if(answer.equals("non")){evaluer = false;}
+
+			while(evaluer){
+				caseEvaluee = joueur.evaluer();
+				evaluerCase(caseEvaluee, joueur);
+
+				System.out.println("Evaluer ? oui / non");
+				answer = input.nextLine();
+				if(answer.equals("non")){evaluer = false;}
 			}
-		} else{
-			finirPartie();
 		}
+
+		System.out.println("Time to play, cowboy!");
+		Case caseJouee = joueur.jouer();
+		System.out.println("bbbb");
+		jouerCase(caseJouee, joueur);
+
+
+
+		this.getPlateau().afficherPlateau();
 	}
 
+	/**
+	 * Vérifie la condition de victoire de la partie
+	 * @return Vrai si la partie est fini (toutes les cases sont coloriées) faux sinon
+	 */
 	private boolean estFini() {
 		return this.getPlateau().getLongueur()*this.getPlateau().getLongueur() == this.getPlateau().getNbCasesColoriees();
 	}
 
+	/**
+	 * Fini la partie et détermine la vainqueur
+	 */
 	public void finirPartie() {
 		//TODO : implementer
-		int score = calculeScore();
+		int score = calculScore();
 		System.out.println(this.score);
-		System.out.println(score > 0? "Bleu gagne" : "Rouge gagne");
+		System.out.println(score > 0? "Bleu gagne" : score < 0? "Rouge gagne" : "Draw!");
 	}
 
-	public int calculeScore() {
-		int score = 0;
+	/**
+	 * Calcule le score du plateau actuel
+	 * @return le score actuel
+	 */
+	public int calculScore() {
+		int score;
 
 		score = this.getPlateau().calculeScore();
 
@@ -59,51 +130,146 @@ public class Partie {
 		return score;
 	}
 
-	public int evaluerCase(int iCase, int jCase, Joueur joueur){
-		return this.getPlateau().EvalCaseBrave(this.getPlateau().getMatrice()[iCase][jCase], joueur, this.score);
+	/**
+	 * Calcule le score potentiel du si joueur joue la case caseJouee
+	 * @param caseJouee la case à évaluer
+	 * @param joueur le joueur qui souhaite évaluer la case caseJouee
+	 * @return le score si joueur joue caseJouee
+	 */
+	public int evaluerCase(Case caseJouee, Joueur joueur){
+		switch(this.regle.regleId()){
+			case 0 :
+				return this.getPlateau().EvalCaseBrave(caseJouee, joueur, this.score);
+			case 1 :
+				return this.getPlateau().EvalCaseTemeraire(caseJouee, joueur, this.score);
+		}
+
+		return 0;
 	}
 
+	/**
+	 * Effectue un coup sur une case
+	 * @param c la case à jouer
+	 * @param joueur le joueur dont c'est le tour
+	 */
 	public void jouerCase(Case c, Joueur joueur){
-		this.getPlateau().colorier(c, joueur, this.regle.regleId());
+		switch (this.regle.regleId()) {
+			case 0 :
+				this.getPlateau().colorierCaseBrave(c, joueur);
+				break;
+			case 1 :
+				this.getPlateau().colorierCaseTemeraire(c, joueur);
+				break;
+		}
 	}
 
+
+	//GETTERS SETTERS
+
+	/**
+	 * @return le score actuel du plateau
+	 */
 	public int getScore() {
 		return score;
 	}
 
+	/**
+	 * Mets à jour le score
+	 * @param score le nouveau score
+	 */
 	public void setScore(int score) {
 		this.score = score;
 	}
 
+	/**
+	 * @return le plateau de jeu
+	 */
 	public Plateau getPlateau() {
 		return plateau;
 	}
 
+	/**
+	 * Définie le plateau de jeu
+	 * @param plateau le nouveau plateau