Eval Cases Braves implementee

src/project/Bot.java

@@ -6,7 +6,14 @@ public class Bot extends Joueur{
 		// TODO Auto-generated constructor stub
 	}
 
-	public void JouerIATemeraire() {
-		
+	@Override
+	public Case jouer() {
+		return JouerIATemeraire();
+	}
+
+	public Case JouerIATemeraire() {
+		//TODO : METHODE OBLIGATOIRE
+
+		return null;
 	}
 }

src/project/Brave.java

 package project;
 
 public class Brave implements Regle{
-
 	@Override
-	public void jouerCase(Case caseBlanche, Joueur joueur, Partie partie) {
-		// TODO Auto-generated method stub
-		
+	public int regleId() {
+		return 0;
 	}
-	
 }

src/project/Case.java

@@ -5,6 +5,7 @@ public class Case{
 	protected int ligne;
 	protected int colonne;
 
+	private PetiteRegion pregion;
 	private boolean acquise;
 	private Couleur couleur;
 	
@@ -14,6 +15,14 @@ public class Case{
 		this.acquise = false;
 		this.setCouleur(Couleur.A);
 	}
+
+	public Case(int i, int j, PetiteRegion pregion) {
+		this.ligne = i;
+		this.colonne = j;
+		this.acquise = false;
+		this.setCouleur(Couleur.A);
+		this.pregion = pregion;
+	}
 	
 	public boolean estAcquise() {
 		return this.acquise;
@@ -35,4 +44,23 @@ public class Case{
 		this.acquise = true;
 	}
 
+	public PetiteRegion getPregion() {
+		return pregion;
+	}
+
+	public void setPregion(PetiteRegion pregion) {
+		this.pregion = pregion;
+	}
+
+	public void colorierBrave(Couleur couleur) {
+		this.setCouleur(couleur);
+	}
+
+	public void colorierTemeraire(Couleur couleur) {
+		this.setCouleur(couleur);
+
+		this.getPregion().updateAcquise();
+		this.getPregion().updateColoriee();
+	}
+
 }
\ No newline at end of file

src/project/Joueur.java

 package project;
 
+import java.util.Scanner;
+
 public class Joueur {
 	Partie partie;
 	Couleur couleur;
@@ -8,12 +10,26 @@ public class Joueur {
 		this.partie = partie;
 		this.couleur = couleur;
 	}
-	
-	public void JouerGloutonBrave(Case caseJouee) {
-		partie.jouer(this, 0, caseJouee);
-	}
-	
-	public void JouerGloutonTemeraire(Case caseJouee) {
-		partie.jouer(this, 1, caseJouee);
+
+	public Case jouer(){
+		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();
+		}
+
+		return partie.getPlateau().getMatrice()[i][j];
 	}
 }

src/project/Main.java

 package project;
 
 
+import java.util.Scanner;
+
 public class Main {
 	public static void main(String[] args) {
-		Plateau plateau = new Plateau(24);
+		/*Menu menu = new Menu();
+
+		while(true){
+			menu.choisirParamètres();
+		}*/
+
+
+		Partie partie = new Partie();
+
+		Scanner console = new Scanner(System.in);
+
+		System.out.println("Brave : 0 / Téméraire : 1");
+
+		int rule = console.nextInt();
+
+		partie.setPlateau(new Plateau(6));
 		
-		plateau.afficherPlateau();
+		if(rule == 0){
+			partie.setRegle(new Brave());
+		}
+
+		if(rule == 1){
+			partie.setRegle(new Temeraire());
+			partie.getPlateau().initalisationQuadtreeEtMatrice();
+		}
+
+		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(plateau.getArbrePlateau().getRoot().getV1().getV2().getRegionSuperieure());
-		Case temp = plateau.getArbrePlateau().rechercheCase(2,20);
+		System.out.println(partie.evaluerCase(1, 0, partie.joueur1));*/
 		
-		Case[] cases = plateau.voisins(temp);
+		partie.demarrerPartie();
+
+		/*Plateau plateau = new Plateau(24);
 		
-		for(int i = 0; i < cases.length; i++) {
-			plateau.colorierCase(cases[i], Couleur.B);
-		}
+		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();
+
+		System.out.println(score);*/
 	}
 }

src/project/Menu.java

 package project;
 
+import java.util.Scanner;
+
 public class Menu {
+    public Menu(){
+
+    }
+
+    public void choisirParametres(){
+
+        Scanner console = new Scanner(System.in);
+
+        //Mode d'initialisation du plateau
+
+        String inputString;
+        int inputInt;
+
+        System.out.println("Plateau de départ : vide / fichier");
+        inputString = console.nextLine();
+
+        while(!inputString.equals("vide") && !inputString.equals("fichier")){
+            System.out.println("Erreur, choisissez parmi ces deux options : vide / fichier");
+            inputString = console.nextLine();
+        }
+
+        String initPlateau = inputString;
+
+
+        if(initPlateau.equals("vide")){
+            //Taille du plateau
+            System.out.println("Rentrez n (le plateau est de taille 3*(2^n))");
+            inputInt = console.nextInt();
+
+            while(inputInt < 0){
+                System.out.println("Erreur, choisissez un nombre positif entier");
+                inputInt = console.nextInt();
+            }
+
+            int taillePlateau = inputInt;
+        } else {
+            //Input de fichier
+            //TODO implémentation de l'initialisation par fichier
+
+        }
+
+        //Séléction des règles
+        System.out.println("Règle du jeu : 0 / 1 (Brave / Téméraire)");
+        inputInt = console.nextInt();
+
+        while(inputInt != 0 && inputInt != 1){
+            System.out.println("Erreur, choisissez parmi ces deux options : 0 / 1 (Brave / Téméraire)");
+            inputInt = console.nextInt();
+        }
+
+        int regleId = inputInt;
+
+
+        //Séléction de la stratégie de l'adversaire
+        int strategieId;
+
+        if(regleId == 1){
+            System.out.println("Règle du jeu : 0 / 1 (Glouton / Smart IA)");
+            inputInt = console.nextInt();
+
+            while(inputInt != 0 && inputInt != 1){
+                System.out.println("Erreur, choisissez parmi ces deux options : 0 / 1 (Glouton / Smart IA)");
+                inputInt = console.nextInt();
+            }
+
+            strategieId = inputInt;
+        }else{
+            System.out.println("Strategie Glouton par défaut ");
+            strategieId = 0;
+        }
+
+        //Séléction de l'affichage du score
+        System.out.println("Afficher le score en permanence? : oui / non");
+        inputString = console.nextLine();
+
+        while(!inputString.equals("oui") && !inputString.equals("non")){
+            System.out.println("Erreur, choisissez parmi ces deux options : oui / non");
+            inputString = console.nextLine();
+        }
+
+        boolean scoreAffiche = inputString.equals("oui");
+
+
+        //Séléction de l'accès a l'évaluation de cases
+        System.out.println("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");
+            inputString = console.nextLine();
+        }
+
+        boolean peutEvaluer = inputString.equals("oui");
+
 
+    }
 }

src/project/Partie.java

@@ -4,15 +4,75 @@ public class Partie {
 	Plateau plateau;
 	Joueur joueur1;
 	Joueur joueur2;
-	Regle règle;
-	int taillePlateau;
-	
-	public int getTaillePlateau() {
-		return taillePlateau;
+	Regle regle;
+	int score;
+
+	public Partie() {
+		this.plateau = null;
+		this.joueur1 = null;
+		this.joueur2 = null;
+		this.regle = null;
+		this.score = 0;
+	}
+
+	public void demarrerPartie() {
+		//TODO : implementer
+
+		tour(joueur1);
+	}
+
+	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(joueur1.equals(joueur)){
+				tour(joueur2);
+			} else{
+				tour(joueur1);
+			}
+		} else{
+			finirPartie();
+		}
 	}
 
-	public void setTailePlateau(int tailePlateau) {
-		this.taillePlateau = tailePlateau;
+	private boolean estFini() {
+		return this.getPlateau().getLongueur()*this.getPlateau().getLongueur() == this.getPlateau().getNbCasesColoriees();
+	}
+
+	public void finirPartie() {
+		//TODO : implementer
+		int score = calculeScore();
+		System.out.println(this.score);
+		System.out.println(score > 0? "Bleu gagne" : "Rouge gagne");
+	}
+
+	public int calculeScore() {
+		int score = 0;
+
+		score = this.getPlateau().calculeScore();
+
+		setScore(score);
+		return score;
+	}
+
+	public int evaluerCase(int iCase, int jCase, Joueur joueur){
+		return this.getPlateau().EvalCaseBrave(this.getPlateau().getMatrice()[iCase][jCase], joueur, this.score);
+	}
+
+	public void jouerCase(Case c, Joueur joueur){
+		this.getPlateau().colorier(c, joueur, this.regle.regleId());
+	}
+
+	public int getScore() {
+		return score;
+	}
+
+	public void setScore(int score) {
+		this.score = score;
 	}
 
 	public Plateau getPlateau() {
@@ -39,47 +99,11 @@ public class Partie {
 		this.joueur2 = joueur2;
 	}
 
-	public Regle getRègle() {
-		return règle;
-	}
-
-	public void setRègle(Regle règle) {
-		this.règle = règle;
+	public Regle getRegle() {
+		return regle;
 	}
 
-	public Partie(Plateau plateau, Joueur joueur1, Joueur joueur2, Regle règle) {
-		this.plateau = plateau;
-		this.joueur1 = joueur1;
-		this.joueur2 = joueur2;
-		this.règle = règle;
-	}
-	
-	public void jouer(Joueur joueur, int regleId, Case caseJouee) {
-
-		   switch(regleId){
-		   
-		       case 0: 
-		           System.out.println("Brave");
-		           //jouer brave
-		           break;
-		   
-		       case 1:
-		           System.out.println("Temeraire");
-		           //jouer temeraire
-		           break;
-		   }
-	}
-	
-	public void demarrerPartie() {
-		//TODO : implementer
-	}
-	
-	public void finirPartie() {
-		//TODO : implementer
-	}
-	
-	public void CalculeScore() {
-		//TODO : METHODE OBLIGATOIRE
+	public void setRegle(Regle regle) {
+		this.regle = regle;
 	}
-	
 }

src/project/PetiteRegion.java

@@ -13,19 +13,101 @@ public class PetiteRegion extends Region{
 		
 		this.cases = new Case[9];
 		this.cases[0] = basGauche;
+		this.cases[0].setPregion(this);
 
 		for(int caseIterator = 1; caseIterator < 9; caseIterator ++) {
 			this.cases[caseIterator] = cases[basGauche.ligne + caseIterator/3][basGauche.colonne + caseIterator%3];
+			this.cases[caseIterator].setPregion(this);
 		}
 	}
-	
-	public void acquerir() {
+
+	public PetiteRegion() {
+		//TODO A IMPLEMENTER
+	}
+
+	@Override
+	public void updateAcquise(){
+		boolean nouveauStatusAcquise = true;
+		int i = 0;
+		while(i < 8 && nouveauStatusAcquise){
+			if(cases[i].getCouleur() != cases[i+1].getCouleur()){
+				nouveauStatusAcquise = false;
+			}
+			i++;
+		}
+
+		this.setAcquise(nouveauStatusAcquise);
+		
+		for(int acqIterator = 0; acqIterator < 9; acqIterator++) {
+			cases[acqIterator].acquerir();
+		}
+
+		if(this.getRegionSuperieure()!=null){
+			this.getRegionSuperieure().updateAcquise();
+		}
+
+	}
+
+	@Override
+	public void updateColoriee() {
+		int i = 0;
+		boolean caseNonColorieeTrouvee = false;
+
+		while(i < 9 && !caseNonColorieeTrouvee) {
+			if(!cases[i].caseColoriee()) {
+				caseNonColorieeTrouvee = true;
+				this.setColoriee(false);
+			}
+			i++;
+		}
+
+		this.setColoriee(!caseNonColorieeTrouvee);
+
+		if(this.getRegionSuperieure()!=null){
+			this.getRegionSuperieure().updateColoriee();
+		}
+	}
+
+	@Override
+	public void acquerir(){
+		this.setAcquise(true);
 		for(int i = 0; i < 9; i++) {
 			cases[i].acquerir();
 		}
 	}
-	
-	
+
+	@Override
+	public void colorierRegion(Couleur couleur) {
+		for(int i = 0; i < 9; i++){
+			cases[i].setCouleur(couleur);
+		}
+
+		this.updateAcquise();
+		this.updateColoriee();
+	}
+
+	@Override
+	public int[] calculeScoreNaif(){
+		int[] returnArray = new int[2];
+
+		//returnArray[0] : le nombre de cases bleues dans cette petite region
+		//returnArray[1] : le nombre de cases rouges dans cette petite region
+		returnArray[0] = 0;
+		returnArray[1] = 0;
+
+		for(int i = 0; i < 9; i++){
+			if(cases[i].getCouleur() == Couleur.B){
+				returnArray[0] = returnArray[0] + 1;
+			}
+
+			if(cases[i].getCouleur() == Couleur.R){
+				returnArray[1] = returnArray[1] + 1;
+			}
+		}
+
+		return returnArray;
+	}
+
 	//GETTERS SETTERS
 	public Case[] getCases() {
 		return cases;

src/project/Plateau.java

 package project;
 
-public class Plateau {
+public class Plateau{
 
 	//attributs
 	private int longueur;
 	private Quadtree arbrePlateau;
+	private int nbCasesColoriees;
 	private Case[][] matrice;
 
+	Plateau(int longueur, String cases){
+		//TODO : implémenter la création de la matrice depuis un fichier
+	}
+
 	//constructeur : un plateau non subdivisé
 	public Plateau (int longueur){
 		this.longueur = longueur;
-		
-		this.initalisationQuadtreeEtMatrice();
+		this.nbCasesColoriees = 0;
+		this.matrice = new Case[longueur][];
+
+		//Initialisation de la matrice et de toutes les cases
+		for(int i = 0; i < longueur; i++) {
+			this.matrice[i] = new Case[longueur];//Le plateau est un carré, donc la longueur est égale à la hauteur
+			for (int j = 0; j < longueur; j++) {
+				this.matrice[i][j] = new Case(i,j);
+			}
+		}
+
+		this.arbrePlateau = null;
 	}
 	
 	public void RemplirRegion() {
@@ -22,44 +37,40 @@ public class Plateau {
 		//TODO : METHODE OBLIGATOIRE
 	}
 
-	public int EvalCaseBrave(Case c) {
-		//TODO : METHODE OBLIGATOIRE
-		return 0;
+	public int EvalCaseBrave(Case c, Joueur joueur, int scoreActuel){
+		Couleur couleur = joueur.couleur;
+		Couleur adversaire = (couleur==Couleur.B? Couleur.R: Couleur.B);
+		int scoreEvalue = scoreActuel;
+		
+		Case[] voisins = this.voisins(c);
+		
+		for(int i = 0; i < voisins.length; i++) {
+			if(voisins[i].getCouleur() == adversaire || voisins[i].equals(c)) {
+				if(couleur == Couleur.B) {
+					scoreEvalue++;
+				} else {
+					scoreEvalue--;
+				}
+			}
+		}
+		
+		return scoreEvalue;
+		
 	}
-	
-	public int EvalCaseTemeraire(Case c) {
+
+	public int EvalCaseTemeraire(Case c, Joueur joueur, int scoreActuel) {
 		//TODO : METHODE OBLIGATOIRE
 		return 0;
 	}
 
 	public void initalisationQuadtreeEtMatrice() {
-		this.matrice = new Case[longueur][];
 		this.setArbrePlateau(new Quadtree());
 		
-		
-		//Initialisation de la matrice et de toutes les cases
-		for(int i = 0; i < longueur; i++) {
-			this.matrice[i] = new Case[longueur];//Le plateau est un carré, donc la longueur est égale à la hauteur
-			for (int j = 0; j < longueur; j++) {
-				this.matrice[i][