changements et reglé erreurs

src/carte/Equipement.java

@@ -1,13 +0,0 @@
-package carte;
-
-import main.Joueur;
-import main.Type;
-
-
-public class Equipement extends CartePiochable<Type>{
-	
-	
-	public void utiliser(Joueur j) {
-		
-	}
-}

src/condition/ConditionType.java

@@ -1,46 +0,0 @@
-package condition;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import main.Joueur;
-
-
-public class ConditionType extends Condition{
-
-	private List<Joueur.Equipe> equipes;
-	
-	public ConditionType(List<Joueur.Equipe> equipes){
-		
-		this.equipes = new ArrayList<Joueur.Equipe>();
-		this.equipes.addAll(equipes);
-	}
-
-
-
-
-	/**
-	 * Vérifie qu'il existe au moins une classe qui correspond à l'équipe du Joueur.
-	 * <br><br>
-	 * exemple : 
-	 * 
-	 * classes = { NEUTRE,SHADOW,HUNTER }
-	 * <br>
-	 * Si l'équipe du joueur correspond à un des élements dans la liste des équipes alors on renvoie vrai.
-	 * 
-	 * @param joueur Le joueur sur lequel on vérifie les conditions.
-	 * @return boolean
-	 */
-	@Override
-	public boolean isTrue(Joueur joueur)
-	{
-		Joueur.Equipe equipeJoueur = joueur.getEquipe();
-		
-		for(Joueur.Equipe equipe : equipes) {
-		
-			if(equipeJoueur == equipe) return true;
-		}
-		return false;
-	}
-	
-}

src/database/CreatingCardsTest.java

@@ -41,7 +41,7 @@ import personnage.Vampire;
 
 public class CreatingCardsTest {
 
-	public static void main(String[] args) {
+	public static void init() {
 		
 		// Lumière
 		

src/effet/ActionAttaquer.java

@@ -1,18 +0,0 @@
-package effet;
-
-import main.Joueur;
-
-public class ActionAttaquer extends Action {
-
-	/**
-	 * Lance l'action d'attaquer
-	 * @param j1 Le joueur qui attaque
-	 * @param j2 Le joueur qui subit l'attaque
-	 * @return void
-	 */
-	@Override
-	public void affecte(Joueur j1, Joueur j2) {
-		j1.attaquer(j2);
-	}
-
-}

src/effet/ActionPiocher.java

@@ -1,22 +0,0 @@
-package effet;
-
-import main.Joueur;
-
-public class ActionPiocher extends Action{
-
-	public ActionPiocher() {
-		super();
-	}
-	
-	/**
-	 * Lance l'action de piocher une carte.
-	 * @param j1 Le joueur qui lance l'action
-	 * @param j2 Le joueur qui subit l'action
-	 * @return void
-	 */
-	@Override
-	public void affecte(Joueur j1, Joueur j2) {
-		j2.piocher();
-	}
-
-}

src/effet/ActionVoler.java

@@ -1,26 +0,0 @@
-package effet;
-
-import main.Equipement;
-import main.Joueur;
-
-public class ActionVoler extends Action{
-
-	
-	/**
-	 * Lance l'action de voler une carte équipement.
-	 * @param j1 Le joueur qui vol
-	 * @param j2 Le joueur volé
-	 * @return void
-	 */
-	@Override
-	public void affecte(Joueur j1, Joueur j2) {
-		
-		Equipement[] equipements = j2.getEquipements();
-		
-		// J1 choisit quel équipement voler
-		Equipement equipement = j1.choisir(equipements);
-		
-		j1.voler(j2,equipement);
-		
-	}
-}

src/ihm/Main.java

@@ -3,6 +3,7 @@ import java.net.URL;
 import java.util.Locale;
 import java.util.ResourceBundle;
 
+import database.CreatingCardsTest;
 import database.RessourceLoader;
 import javafx.application.Application;
 import javafx.event.EventHandler;
@@ -40,9 +41,8 @@ public class Main extends Application {
 	}
 
 	public static void main(String[] args) {
-		
+		CreatingCardsTest.init();
 		GestionnaireJeu gj = GestionnaireJeu.getGestionnaireJeu();
-		
 		RessourceLoader rl = new RessourceLoader();
 		rl.loadRessources();
 		gj.setRessourceLoader(rl);

src/ihm/controller/PlateauController.java

@@ -626,4 +626,9 @@ public class PlateauController implements Initializable {
 		jihm.reveler();
 	}
 
+	public void utiliserCapacite(Joueur joueur) {
+		JoueurIHM jihm = getJoueurIHM(joueur);
+		jihm.getRevealButton().fire();
+	}
+
 }

src/main/GestionnaireJeu.java

@@ -371,4 +371,10 @@ public class GestionnaireJeu {
 			pc.revealJoueur(joueur);
 		});
 	}
+
+	public void utiliserCapacite(Joueur joueur) {
+		Platform.runLater(() -> {
+			pc.utiliserCapacite(joueur);
+		});		
+	}
 }

src/main/JoueurVirtuel.java

@@ -59,10 +59,10 @@ public class JoueurVirtuel extends Joueur {
 			res = choisirJoueurAmi(joueurs);
 			break;
 		case CHOISIR_VISION:
-			res = joueurs.get((int) Math.floor(Math.random() * joueurs.size())); // a revoir inshallah
+			res = choisirJoueurEnnemi(joueurs); // a revoir inshallah
 			break;
 		default:
-			res = null; // faire exception?
+			res = choisirJoueurEnnemi(joueurs); // faire exception?
 		}
 		return res;
 	}

src/main/Plateau.java

@@ -27,12 +27,12 @@ import personnage.CartePersonnage.Equipe;
 import personnage.Franklin;
 import personnage.Vampire;
 
-public class Plateau extends Thread{
-	
+public class Plateau extends Thread {
+
 	private GestionnaireJeu gj;
 	private List<Joueur> joueurs;
 	private List<CarteLieu> lieux;
-	
+
 	public static final String NB_HUNTERS = "nb_hunters";
 	public static final String NB_SHADOWS = "nb_shadows";
 	public static final String NB_NEUTRES = "nb_neutres";
@@ -42,58 +42,62 @@ public class Plateau extends Thread{
 	public static final String NB_MORTS_SHADOW = "nb_morts_shadow";
 	public static final String PARTIE_FINIE = "partie_finie";
 	public static final String WIN_CHARLES = "victoire_charles";
-	
+
 	private Map<String, Integer> stats;
-	
+
 	public Plateau(List<Joueur> joueurs) {
-		
+
 		gj = GestionnaireJeu.getGestionnaireJeu();
-		
+
 		this.lieux = new ArrayList<>();
 		this.stats = new HashMap<>();
-		
+
 		joueurs.forEach(x -> x.setPlateau(this));
 		this.joueurs = joueurs;
-		
-		
+
 		this.stats.put(NB_MORTS, 0);
 		this.stats.put(NB_MORTS_NEUTRAL, 0);
 		this.stats.put(NB_MORTS_HUNTER, 0);
 		this.stats.put(NB_MORTS_SHADOW, 0);
 		this.stats.put(PARTIE_FINIE, 0);
-		
+
 		this.stats.put(NB_HUNTERS, 0);
 		this.stats.put(NB_SHADOWS, 0);
 		this.stats.put(NB_NEUTRES, 0);
-		
+
 		List<CartePiochable> list1 = new ArrayList<>();
 		List<CartePiochable> list2 = new ArrayList<>();
-		
-		for(int i = 0; i < 60; i++) {
-			
-			CartePiochable carte1 = new CartePiochable(CartePiochable.Type.LUMIERE,"Eau bénite", "Soin 2");
+
+		for (int i = 0; i < 60; i++) {
+
+			CartePiochable carte1 = new CartePiochable(CartePiochable.Type.LUMIERE, "Eau bénite", "Soin 2");
 			carte1.setEffet(new EffetSelf(new ActionAltererStatistiquesJoueur(Joueur.PLAYER_HP, 2, true)));
 			list1.add(carte1);
-			
-			CartePiochable carte2 = new CartePiochable(CartePiochable.Type.TENEBRE,"Eau maudite", "Damage 2");
+
+			CartePiochable carte2 = new CartePiochable(CartePiochable.Type.TENEBRE, "Eau maudite", "Damage 2");
 			carte2.setEffet(new EffetSelf(new ActionAltererStatistiquesJoueur(Joueur.PLAYER_HP, -2, true)));
 			list2.add(carte2);
 		}
-		
+
 		Pioche piocheLumiere = new Pioche(list1);
 		Pioche piocheTenebre = new Pioche(list2);
-		
-		CarteLieu lieu1 = new CarteLieuType(CartePiochable.Type.TENEBRE,"Antre de l'Ermite","desc",new Point(2,3),piocheTenebre);
-		CarteLieu lieu2 = new CarteLieuType(CartePiochable.Type.TENEBRE,"Cimetière","desc",new Point(-1,8),piocheTenebre);
-		CarteLieu lieu3 = new CarteLieu("Forêt hantée","desc",new Point(-1,9));
-		lieu3.setEffet(new EffetChoisirEffet(new EffetChoisirCible(new ActionAltererStatistiquesJoueur(Joueur.PLAYER_HP,-2,true)),
-											new EffetChoisirCible(new ActionAltererStatistiquesJoueur(Joueur.PLAYER_HP,1,true))));
-		CarteLieu lieu4 = new CarteLieuType(CartePiochable.Type.LUMIERE,"Monastère","desc",new Point(-1,6),piocheLumiere);
-		
-		CarteLieu lieu5 = new CarteLieuType(CartePiochable.Type.TENEBRE,"Sanctuaire Ancien","desc",new Point(4,5),piocheTenebre);
-		CarteLieu lieu6 = new CarteLieu("Sanctuaire Ancien","desc",new Point(-1,9));
+
+		CarteLieu lieu1 = new CarteLieuType(CartePiochable.Type.TENEBRE, "Antre de l'Ermite", "desc", new Point(2, 3),
+				piocheTenebre);
+		CarteLieu lieu2 = new CarteLieuType(CartePiochable.Type.TENEBRE, "Cimetière", "desc", new Point(-1, 8),
+				piocheTenebre);
+		CarteLieu lieu3 = new CarteLieu("Forêt hantée", "desc", new Point(-1, 9));
+		lieu3.setEffet(new EffetChoisirEffet(
+				new EffetChoisirCible(new ActionAltererStatistiquesJoueur(Joueur.PLAYER_HP, -2, true)),
+				new EffetChoisirCible(new ActionAltererStatistiquesJoueur(Joueur.PLAYER_HP, 1, true))));
+		CarteLieu lieu4 = new CarteLieuType(CartePiochable.Type.LUMIERE, "Monastère", "desc", new Point(-1, 6),
+				piocheLumiere);
+
+		CarteLieu lieu5 = new CarteLieuType(CartePiochable.Type.TENEBRE, "Sanctuaire Ancien", "desc", new Point(4, 5),
+				piocheTenebre);
+		CarteLieu lieu6 = new CarteLieu("Sanctuaire Ancien", "desc", new Point(-1, 9));
 		lieu6.setEffet(new EffetChoisirCible(new ActionVoler(ActionVoler.VOLER)));
-	
+
 		List<CarteLieu> cls = new ArrayList<CarteLieu>();
 		cls.add(lieu6);
 		cls.add(lieu5);
@@ -101,20 +105,19 @@ public class Plateau extends Thread{
 		cls.add(lieu3);
 		cls.add(lieu2);
 		cls.add(lieu1);
-		
+
 		List<CartePersonnage> personnages = new ArrayList<CartePersonnage>();
-		
-		
-		for(int i = 0 ; i <3 ; i++) {
-			
+
+		for (int i = 0; i < 3; i++) {
+
 			personnages.add(new Franklin());
 			personnages.add(new Vampire());
 		}
-		
-		for(int i = 0; i < 2; i++) {
+
+		for (int i = 0; i < 2; i++) {
 			personnages.add(new Allie());
 		}
-		
+
 		try {
 			initCartePersonnage(personnages);
 		} catch (Exception e) {
@@ -123,17 +126,17 @@ public class Plateau extends Thread{
 		}
 		setLieux(cls);
 		shuffleLieux();
-		
-	}	
-	
+
+	}
+
 	public Plateau(List<Joueur> joueurs, List<Carte> cartes) {
-		
+
 		this.gj = GestionnaireJeu.getGestionnaireJeu();
 		this.lieux = new ArrayList<>();
 		this.stats = new HashMap<>();
-		
+
 		this.joueurs = joueurs;
-		
+
 		this.stats.put(NB_MORTS, 0);
 		this.stats.put(NB_MORTS_NEUTRAL, 0);
 		this.stats.put(NB_MORTS_HUNTER, 0);
@@ -142,35 +145,33 @@ public class Plateau extends Thread{
 		this.stats.put(NB_HUNTERS, 0);
 		this.stats.put(NB_SHADOWS, 0);
 		this.stats.put(NB_NEUTRES, 0);
-		
-		
+
 		joueurs.forEach(x -> x.setPlateau(this));
-		
-		
+
 		List<CartePiochable> lumiere = RessourceLoader.getCartesType(CartePiochable.Type.LUMIERE, cartes);
 		List<CartePiochable> tenebre = RessourceLoader.getCartesType(CartePiochable.Type.TENEBRE, cartes);
 		List<CartePiochable> vision = RessourceLoader.getCartesType(CartePiochable.Type.VISION, cartes);
-		
-		System.out.println("VISION "+vision);
+
+		System.out.println("VISION " + vision);
 		Map<CartePiochable.Type, List<CartePiochable>> map = new HashMap<CartePiochable.Type, List<CartePiochable>>();
-		map.put(CartePiochable.Type.LUMIERE,lumiere);
-		map.put(CartePiochable.Type.TENEBRE,tenebre);
-		map.put(CartePiochable.Type.VISION,vision);
-		
+		map.put(CartePiochable.Type.LUMIERE, lumiere);
+		map.put(CartePiochable.Type.TENEBRE, tenebre);
+		map.put(CartePiochable.Type.VISION, vision);
+
 		List<CarteLieu> lieux = RessourceLoader.getCartesType(cartes);
-		
+
 		lieux.forEach(x -> {
-			
-			if(x instanceof CarteLieuType) {
-				CarteLieuType clt = (CarteLieuType)x;
+
+			if (x instanceof CarteLieuType) {
+				CarteLieuType clt = (CarteLieuType) x;
 				System.out.println(clt.getType());
-				System.out.println("Oui "+ map.get(clt.getType()));
+				System.out.println("Oui " + map.get(clt.getType()));
 				clt.setPioche(new Pioche(map.get(clt.getType())));
 			}
-			
-			if(x instanceof CarteLieuMultiple) {
-				CarteLieuMultiple clm = (CarteLieuMultiple)x;
-				
+
+			if (x instanceof CarteLieuMultiple) {
+				CarteLieuMultiple clm = (CarteLieuMultiple) x;
+
 				List<Pioche> lp = new ArrayList<Pioche>();
 				lp.add(new Pioche(map.get(CartePiochable.Type.LUMIERE)));
 				lp.add(new Pioche(map.get(CartePiochable.Type.TENEBRE)));
@@ -178,79 +179,77 @@ public class Plateau extends Thread{
 				clm.setPioches(lp);
 			}
 		});
-	
-		
-		
+
 		List<CartePersonnage> personnages = RessourceLoader.getCartesPersonnages(cartes);
-				
+
 		try {
 			initCartePersonnage(personnages);
 		} catch (Exception e) {
-		
+
 		}
 		setLieux(lieux);
 	}
 
 	public void initCartePersonnage(List<CartePersonnage> cps) throws Exception {
-		
+
 		System.out.println(cps);
 		int nbJoueurs = this.joueurs.size();
 		List<CartePersonnage> lcp = new ArrayList<>(nbJoueurs);
-		
-		switch(nbJoueurs) {
-		
+
+		switch (nbJoueurs) {
+
 		case 4:
-			lcp = getRandomListPersonnages(cps,2,0);
+			lcp = getRandomListPersonnages(cps, 2, 0);
 			break;
 		case 5:
-			lcp = getRandomListPersonnages(cps,2,1);
+			lcp = getRandomListPersonnages(cps, 2, 1);
 			break;
 		case 6:
-			lcp = getRandomListPersonnages(cps,2,2);
+			lcp = getRandomListPersonnages(cps, 2, 2);
 			break;
 		case 7:
-			lcp = getRandomListPersonnages(cps,2,3);
+			lcp = getRandomListPersonnages(cps, 2, 3);
 			break;
 		case 8:
-			lcp = getRandomListPersonnages(cps,3,2);
+			lcp = getRandomListPersonnages(cps, 3, 2);
 			break;
 		default:
 			throw new Exception();
 		}
-		
+
 		System.out.println(lcp);
-		for(int i = 0; i< nbJoueurs; i++) {
-			
+		for (int i = 0; i < nbJoueurs; i++) {
+
 			Joueur j = joueurs.get(i);
 			j.setCartePersonnage(lcp.get(i));
 			lcp.get(i).setJoueur(j);
 		}
 	}
-	
-	private List<CartePersonnage> getRandomListPersonnages(List<CartePersonnage> cps,int nbEquipeShadowHunter, int nbNeutres) {
-		
+
+	private List<CartePersonnage> getRandomListPersonnages(List<CartePersonnage> cps, int nbEquipeShadowHunter,
+			int nbNeutres) {
+
 		List<CartePersonnage> lcp = new ArrayList<CartePersonnage>();
-		
+
 		Collections.shuffle(cps);
-		
+
 		int nbShadow = nbEquipeShadowHunter;
 		int nbHunter = nbEquipeShadowHunter;
 		int nbNeutre = nbNeutres;
-		
-		for(CartePersonnage cp : cps) {
-			
-			
-			if(nbHunter > 0 && cp.getEquipe() == CartePersonnage.Equipe.HUNTER) {
+
+		for (CartePersonnage cp : cps) {
+
+			if (nbHunter > 0 && cp.getEquipe() == CartePersonnage.Equipe.HUNTER) {
 				nbHunter--;
 				lcp.add(cp);
 			}
-			
-			if(nbNeutre > 0 && cp.getEquipe() == CartePersonnage.Equipe.NEUTRE) {
+
+			if (nbNeutre > 0 && cp.getEquipe() == CartePersonnage.Equipe.NEUTRE) {
 				nbNeutre--;
 				lcp.add(cp);
 			}
-			
-			if(nbShadow > 0 && cp.getEquipe() == CartePersonnage.Equipe.SHADOW) {
+
+			if (nbShadow > 0 && cp.getEquipe() == CartePersonnage.Equipe.SHADOW) {
 				nbShadow--;
 				lcp.add(cp);
 			}
@@ -260,63 +259,132 @@ public class Plateau extends Thread{
 	}
 
 	public void run() {
-		
+
 		int nbJoueurs = this.joueurs.size();
 		int i = 0;
-		
-		while(!isPartieTerminee()) {
-			
-			Joueur currentJoueur = this.joueurs.get(i % nbJoueurs);		
-			
-			if(!currentJoueur.isDead()) {	
-			
-				deplacer(currentJoueur);
-				if(isPartieTerminee()) break;
-				gj.afficherLieu(currentJoueur);
-				
-				if(currentJoueur.choisir(Contexte.ACTIVER_EFFET_LIEU)) {
-					currentJoueur.utiliserEffetLieu();
-					if(isPartieTerminee()) break;
+
+		while (!isPartieTerminee()) {
+
+			Joueur currentJoueur = this.joueurs.get(i % nbJoueurs);
+
+			if (!currentJoueur.isDead()) {
+				if (currentJoueur instanceof JoueurVirtuel) {
+					if (checkrevealIAtour((JoueurVirtuel) currentJoueur))
+						currentJoueur.reveal();
+					currentJoueur.utiliserCapacite();
 				}
-	
-				if(currentJoueur.choisir(Contexte.ATTAQUER)){
-					if(currentJoueur.hasOpponents()) {
+
+				deplacer(currentJoueur);
+				if (isPartieTerminee())
+					break;
+				gj.afficherLieu(currentJoueur);
+
+				if (currentJoueur.choisir(Contexte.ACTIVER_EFFET_LIEU)) {
+					currentJoueur.utiliserEffetLieu();
+					if (isPartieTerminee())
+						break;
+				}
+
+				if (currentJoueur.choisir(Contexte.ATTAQUER)) {
+					if (currentJoueur.hasOpponents()) {
 						List<Joueur> adjacents = currentJoueur.getJoueursRange();
-						Joueur cible = (Joueur) currentJoueur.choisir(adjacents,Contexte.ATTAQUER);
-						attaquer(currentJoueur,cible);
-						if(isPartieTerminee()) break;
-					}else {
+						Joueur cible = (Joueur) currentJoueur.choisir(adjacents, Contexte.ATTAQUER);
+						if (currentJoueur instanceof JoueurVirtuel) {
+							if (checkrevealIAattaque((JoueurVirtuel) currentJoueur, cible))
+								currentJoueur.reveal();
+								currentJoueur.utiliserCapacite();
+						}
+						if (currentJoueur instanceof JoueurVirtuel) {
+							if (checkrevealIAattaquee((JoueurVirtuel) cible, currentJoueur))
+								cible.reveal();
+								cible.utiliserCapacite();
+						}
+						attaquer(currentJoueur, cible);
+						if (isPartieTerminee())
+							break;
+					} else {
 						System.out.println("Il n'y a personne a attaquer.");
 					}
 				}
 				i++;
 			}
 		}
-		
+
 		List<Joueur> gagnants = new ArrayList<Joueur>();
-		
+
 		System.out.println(this.stats);
-		for(Joueur j : joueurs) {
-			if(j.victoire()) {
+		for (Joueur j : joueurs) {
+			if (j.victoire()) {
 				gagnants.add(j);
-				System.out.println("CartePersonnage "+j.getCartePersonnage()+" Stats "+j.getStats());
+				System.out.println("CartePersonnage " + j.getCartePersonnage() + " Stats " + j.getStats());
 			}
-		}	
+		}
 	}
-	
+
+	private boolean checkrevealIAtour(JoueurVirtuel jIA) {
+		ControleurIA cIA = new ControleurIA();
+		switch (jIA.getCartePersonnage().getNom()) {
+		case "ALLIE":
+			return cIA.devoilerIAAllie(jIA);
+		case "DANIEL":
+			return false;
+		case "FRANKLIN":
+			return cIA.devoilerIAFranklin(jIA, joueurs);
+		case "GEORGES":
+			return cIA.devoilerIAGeorges(jIA, joueurs);
+		case "EMI":
+			return cIA.devoilerIAEmi(jIA, jIA.getCarteLieu());
+		case "METAMORPHE":
+			return false;
+		default:
+		}
+		return false;
+	}
+
+	private boolean checkrevealIAattaque(JoueurVirtuel jIA, Joueur jAttaquee) {
+		ControleurIA cIA = new ControleurIA();
+		switch (jIA.getCartePersonnage().getNom()) {
+		case "ALLIE":
+			return cIA.devoilerIAAllie(jIA);
+		case "BOB":
+			return cIA.devoilerIABob(jIA, jAttaquee);
+		case "VAMPIRE":
+			return cIA.devoilerIAVampire(jIA, jAttaquee);
+		case "CHARLES":
+			return cIA.devoilerIACharles(jIA, jAttaquee);
+		case "FRANKLIN":
+			return cIA.devoilerIAFranklin(jIA, joueurs);
+		case "GEORGES":
+			return cIA.devoilerIAGeorges(jIA, joueurs);
+		default:
+		}
+		return false;
+	}
+
+	private boolean checkrevealIAattaquee(JoueurVirtuel jIA, Joueur jAttaquant) {
+		ControleurIA cIA = new ControleurIA();
+		switch (jIA.getCartePersonnage().getNom()) {
+		case "LOUP-GAROU":
+			return cIA.devoilerIALoupGarou(jIA, jAttaquant);
+		default:
+		}
+		return false;
+	}
+
 	public boolean isPartieTerminee() {
-		return this.getStat(PARTIE_FINIE) == 1;
+		return false;
+		// return this.getStat(PARTIE_FINIE) == 1;
 	}
 
 	public void deplacer(Joueur currentJoueur) {
-		
+
 		boolean attributed = false;
-		
-		while(!attributed) {
+
+		while (!attributed) {
 			int roll = sumRolls(currentJoueur);
-			
-			for(CarteLieu cl : lieux) {	
-				if(cl.coordinatesContains(roll) && currentJoueur.getCarteLieu() != cl){
+
+			for (CarteLieu cl : lieux) {
+				if (cl.coordinatesContains(roll) && currentJoueur.getCarteLieu() != cl) {
 					currentJoueur.deplacer(cl);
 					attributed = true;
 					break;
@@ -325,65 +393,64 @@ public class Plateau extends Thread{
 		}
 		gj.deplacer(currentJoueur);
 	}
-	
+
 	public void attaquer(Joueur joueur1, Joueur joueur2) {
-		
+
 		int attaque = diffRolls(joueur1);
-		
-		if(attaque != 0) {
-			System.out.println(joueur1.getNom()+" attaque "+joueur2.getNom());
-			System.out.println(joueur2.getNom()+" a "+joueur2.getStat(Joueur.PLAYER_HP)+" pv");
-			joueur1.attaquer(joueur2,attaque);
-			System.out.println(joueur2.getNom()+" passe à "+joueur2.getStat(Joueur.PLAYER_HP)+" pv");
+
+		if (attaque != 0) {
+			System.out.println(joueur1.getNom() + " attaque " + joueur2.getNom());
+			System.out.println(joueur2.getNom() + " a " + joueur2.getStat(Joueur.PLAYER_HP) + " pv");
+			joueur1.attaquer(joueur2, attaque);
+			System.out.println(joueur2.getNom() + " passe à " + joueur2.getStat(Joueur.PLAYER_HP) + " pv");
 		}
 	}
-	
+
 	public Joueur selectionnerJoueur() {
 		return new Joueur("0");
 	}
-	
+
 	public int diffRolls(Joueur j) {
-		
-		int roll4 =rollRandom(4);
+
+		int roll4 = rollRandom(4);
 		int roll6 = rollRandom(6);
-		gj.rollDice(j, PlateauController.DICE_BOTH, roll4,roll6);
-		return Math.abs(roll4-roll6);
+		gj.rollDice(j, PlateauController.DICE_BOTH, roll4, roll6);
+		return Math.abs(roll4 - roll6);
 	}
-	
+
 	public int roll4(Joueur j) {
-		
+
 		int roll = this.rollRandom(4);
 		gj.rollDice(j, PlateauController.DICE_QUATRE, roll);
 		return roll;
 	}
-	
+
 	public int roll6(Joueur j) {
-		
+
 		int roll = this.rollRandom(6);
 		gj.rollDice(j, PlateauController.DICE_SIX, roll);
 		return roll;
 	}
-	
+
 	private int rollRandom(int nb) {
-		Random r= new Random();
-		int roll = r.nextInt(nb)+1;
+		Random r = new Random();
+		int roll = r.nextInt(nb) + 1;
 		return roll;
 	}
 
-	public int sumRolls(Joueur j)
-	{
+	public int sumRolls(Joueur j) {
 		int sum = 0;
 		int roll4 = 0;
 		int roll6 = 0;
-	
+
 		roll4 = rollRandom(4);
 		roll6 = rollRandom(6);
-		sum = Math.abs(roll4+roll6);
-	
-		gj.rollDice(j, PlateauController.DICE_BOTH, roll4,roll6);
+		sum = Math.abs(roll4 + roll6);
+
+		gj.rollDice(j, PlateauController.DICE_BOTH, roll4, roll6);
 		return sum;
 	}
-	
+
 	public List<Joueur> getJoueurs() {
 		return this.joueurs;
 	}
@@ -391,41 +458,39 @@ public class Plateau extends Thread{
 	public void setStat(String key, int valeur) {
 		this.stats.put(key, valeur);
 	}
-	
+
 	public int getStat(String key) {
-		
-		if(this.stats.containsKey(key))
-		{
+
+		if (this.stats.containsKey(key)) {
 			return this.stats.get(key);
-		}else {
+		} else {
 			return -1;
-		}	
+		}
 	}
-	
-	public void shuffleLieux(){
-		
+
+	public void shuffleLieux() {
+
 		this.lieux.forEach(x -> x.setVoisin(null));
-		
-		if(lieux.size() % 2 == 0) {
-			
+
+		if (lieux.size() % 2 == 0) {
+
 			Collections.shuffle(lieux);
-			
-			for(int i = 0; i < lieux.size(); i += 2) {	
-				lieux.get(i).setVoisin(lieux.get(i+1));
-				lieux.get(i+1).setVoisin(lieux.get(i));
+
+			for (int i = 0; i < lieux.size(); i += 2) {
+				lieux.get(i).setVoisin(lieux.get(i + 1));
+				lieux.get(i + 1).setVoisin(lieux.get(i));
 			}
 		}
 	}
-	
+
 	public void setLieux(List<CarteLieu> lieux) {
 		this.lieux = lieux;
 		shuffleLieux();
 	}
-	
+
 	public List<CarteLieu> getLieux() {
 		return this.lieux;
 	}
-	
 
 	public boolean choisir(Joueur joueur, Contexte contexte) {
 		return gj.choisir(joueur, contexte);
@@ -434,24 +499,23 @@ public class Plateau extends Thread{
 	public Joueur choisirAdjacents(Joueur joueur) {
 		List<Joueur> joueurs = new ArrayList<Joueur>();
 		CarteLieu cl = joueur.getCarteLieu();
-		
+
 		joueurs.addAll(cl.getJoueurs());
 		joueurs.addAll(cl.getJoueursAdjacents());
 		joueurs.remove(joueur);
-		
+
 		removeDeads(joueurs);
 		return (Joueur) gj.choisir(joueur, joueurs, Joueur.class);
 	}
 
-
 	private void removeDeads(List<Joueur> joueurs) {
-		
+
 		List<Joueur> toRemove = new ArrayList<Joueur>();
-		for(Joueur j : joueurs) {
-		
-			if(j.isDead()) {
+		for (Joueur j : joueurs) {
+
+			if (j.isDead()) {
 				toRemove.add(j);
-			}		
+			}
 		}
 		joueurs.removeAll(toRemove);
 	}
@@ -465,26 +529,26 @@ public class Plateau extends Thread{
 	}
 
 	public void updateVieJoueur(Joueur joueur, int damage) {
-		gj.updateVieJoueur(joueur,damage);
-		
+		gj.updateVieJoueur(joueur, damage);
+
 	}
 
 	public Object choisir(Joueur joueur, List<?> list, Class cls) {
-		return gj.choisir(joueur,list,cls);
+		return gj.choisir(joueur, list, cls);
 	}
 
 	public void alerationVie(Joueur joueur, int valeur) {
-		gj.alterationVie(joueur,valeur);
+		gj.alterationVie(joueur, valeur);
 	}
 
 	public void ajouterEquipementIHM(Joueur joueur, CarteEquipement e) {
-		gj.ajouterEquipement(joueur,e);
-		
+		gj.ajouterEquipement(joueur, e);
+
 	}
 
 	public void retirerEquipementIHM(Joueur joueur, CarteEquipement e) {
-		gj.retirerEquipement(joueur,e);
-		
+		gj.retirerEquipement(joueur, e);
+
 	}
 
 	public Joueur choisir(Joueur joueur, List<Joueur> adjacents, Contexte attaquer) {
@@ -492,36 +556,37 @@ public class Plateau extends Thread{
 	}
 
 	public void death(Joueur joueur) {
-		
+
 		Equipe ej = joueur.getEquipe();
-		
-		switch(ej) {
+
+		switch (ej) {
 		case SHADOW:
-			this.updateStat(NB_MORTS_SHADOW,1,true);
+			this.updateStat(NB_MORTS_SHADOW, 1, true);
 			break;
 		case HUNTER:
-			this.updateStat(NB_MORTS_HUNTER,1,true);
+			this.updateStat(NB_MORTS_HUNTER, 1, true);
 			break;
 		case NEUTRE:
-			this.updateStat(NB_MORTS_NEUTRAL,1,true);
-			break;}
-		
-		this.updateStat(NB_MORTS,1,true);
-		
+			this.updateStat(NB_MORTS_NEUTRAL, 1, true);
+			break;
 		}
 
-	private void updateStat(String key , int value, boolean ajouter) {
-		if(ajouter) {
+		this.updateStat(NB_MORTS, 1, true);
+
+	}
+
+	private void updateStat(String key, int value, boolean ajouter) {
+		if (ajouter) {
 			int valeurBase = this.getStat(key);
-			this.setStat(key, valeurBase+value);
-		}else {
+			this.setStat(key, valeurBase + value);
+		} else {
 			this.setStat(key, value);
 		}
-		
+
 	}
 
 	public void victoire(Joueur joueur) {
-		if(joueur.victoire()) {
+		if (joueur.victoire()) {
 			this.updateStat(PARTIE_FINIE, 1, false);
 		}
 	}