diff --git a/src/main/java/com/montaury/mus/Mus.java b/src/main/java/com/montaury/mus/Mus.java index 56300eb..0e6b597 100644 --- a/src/main/java/com/montaury/mus/Mus.java +++ b/src/main/java/com/montaury/mus/Mus.java @@ -1,9 +1,10 @@ package com.montaury.mus; import com.montaury.mus.jeu.Partie; +import com.montaury.mus.jeu.equipe.Equipe; import com.montaury.mus.jeu.joueur.AffichageConsoleEvenementsDeJeu; import com.montaury.mus.jeu.joueur.Joueur; -import com.montaury.mus.jeu.joueur.Opposants; +import com.montaury.mus.jeu.equipe.Opposants; import java.util.Scanner; public class Mus { @@ -13,7 +14,8 @@ public static void main(String[] args) { Joueur humain = Joueur.humain(nomJoueur); Partie partie = new Partie(new AffichageConsoleEvenementsDeJeu(humain)); - Partie.Resultat resultat = partie.jouer(new Opposants(humain, Joueur.ordinateur())); + Partie.Resultat resultat = partie.jouer(new Opposants( new Equipe( humain, Joueur.ordinateur("allié") ), + new Equipe(Joueur.ordinateur("enemie 1"),Joueur.ordinateur("enemie 2")))); System.out.println("Le vainqueur de la partie est " + resultat.vainqueur().nom()); } diff --git a/src/main/java/com/montaury/mus/jeu/Manche.java b/src/main/java/com/montaury/mus/jeu/Manche.java index f8f109a..05c15cd 100644 --- a/src/main/java/com/montaury/mus/jeu/Manche.java +++ b/src/main/java/com/montaury/mus/jeu/Manche.java @@ -2,7 +2,7 @@ import com.montaury.mus.jeu.joueur.AffichageEvenementsDeJeu; import com.montaury.mus.jeu.joueur.Joueur; -import com.montaury.mus.jeu.joueur.Opposants; +import com.montaury.mus.jeu.equipe.Opposants; import com.montaury.mus.jeu.tour.Tour; import java.util.HashMap; import java.util.Map; @@ -32,8 +32,12 @@ public static class Score { private final Map scoreParJoueur = new HashMap<>(); public Score(Opposants opposants) { - scoreParJoueur.put(opposants.joueurEsku(), 0); - scoreParJoueur.put(opposants.joueurZaku(), 0); + scoreParJoueur.put(opposants.joueur1(), 0); + scoreParJoueur.put(opposants.joueur3(), 0); + scoreParJoueur.put(opposants.joueur2(), 0); + scoreParJoueur.put(opposants.joueur4(), 0); + + } public Map scoreParJoueur() { diff --git a/src/main/java/com/montaury/mus/jeu/Partie.java b/src/main/java/com/montaury/mus/jeu/Partie.java index 474f68f..fd8f0d8 100644 --- a/src/main/java/com/montaury/mus/jeu/Partie.java +++ b/src/main/java/com/montaury/mus/jeu/Partie.java @@ -2,7 +2,7 @@ import com.montaury.mus.jeu.joueur.AffichageEvenementsDeJeu; import com.montaury.mus.jeu.joueur.Joueur; -import com.montaury.mus.jeu.joueur.Opposants; +import com.montaury.mus.jeu.equipe.Opposants; import java.util.ArrayList; import java.util.HashMap; import java.util.List; @@ -35,8 +35,10 @@ public static class Score { private final Map manchesGagneesParJoueur = new HashMap<>(); public Score(Opposants opposants) { - this.manchesGagneesParJoueur.put(opposants.joueurEsku(), 0); - this.manchesGagneesParJoueur.put(opposants.joueurZaku(), 0); + this.manchesGagneesParJoueur.put(opposants.joueur1(), 0); + this.manchesGagneesParJoueur.put(opposants.joueur3(), 0); + this.manchesGagneesParJoueur.put(opposants.joueur2(), 0); + this.manchesGagneesParJoueur.put(opposants.joueur4(), 0); } public Optional enregistrer(Manche.Resultat score) { diff --git a/src/main/java/com/montaury/mus/jeu/equipe/Equipe.java b/src/main/java/com/montaury/mus/jeu/equipe/Equipe.java new file mode 100644 index 0000000..27b3405 --- /dev/null +++ b/src/main/java/com/montaury/mus/jeu/equipe/Equipe.java @@ -0,0 +1,28 @@ +package com.montaury.mus.jeu.equipe; + +import com.montaury.mus.jeu.Manche; +import com.montaury.mus.jeu.joueur.Joueur; + +public class Equipe { + //attribut + public Joueur joueur1; + public Joueur joueur2; + + //constructeur + public Equipe(Joueur j1, Joueur j2) + { + joueur1 = j1; + joueur2 = j2; + } + //methodes + + public Joueur getJoueur1() { + return joueur1; + } + + public Joueur getJoueur2() { + return joueur2; + } + + +} diff --git a/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java b/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java new file mode 100644 index 0000000..0d453ee --- /dev/null +++ b/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java @@ -0,0 +1,95 @@ +package com.montaury.mus.jeu.equipe; + +import com.montaury.mus.jeu.joueur.Joueur; + +import java.util.Iterator; + +import java.util.LinkedList; +import java.util.List; + +public class Opposants { + private Equipe equipe1; + private Equipe equipe2; + private LinkedList joueursDansLordre; + + + public Opposants(Equipe equipe1, Equipe equipe2) { + this.equipe1 = equipe1; + this.equipe2 = equipe2; + joueursDansLordre = new LinkedList(); + joueursDansLordre.add(joueur1()); + joueursDansLordre.add(joueur3()); + joueursDansLordre.add(joueur2()); + joueursDansLordre.add(joueur4()); + } + // permet de changer celui qui distribue et celui qui parle en premier + public void tourner() { + Joueur jouerTempon = joueursDansLordre.removeLast(); + joueursDansLordre.addFirst(jouerTempon); + equipe1.joueur1=joueursDansLordre.get(0); + equipe2.joueur1=joueursDansLordre.get(1); + equipe1.joueur2=joueursDansLordre.get(2); + equipe2.joueur2=joueursDansLordre.get(3); + } + + public Joueur joueur1() { + return equipe1.joueur1; + } + public Joueur joueur2() {return equipe1.joueur2;} + public Joueur joueur3() { + return equipe2.joueur1; + } + public Joueur joueur4() { + return equipe2.joueur2; + } + + public Iterator itererDansLOrdre() { //permet de passer d'un Joueur a l autre pour avoir ses données + return new IteratorInfini(this); + } + + public List dansLOrdre() { + return joueursDansLordre; + } + + private static class IteratorInfini implements Iterator { + private final Opposants opposants; + private Joueur suivant; + + public IteratorInfini(Opposants opposants) { + this.opposants = opposants; + suivant = opposants.equipe1.joueur1; + } + + @Override + public boolean hasNext() { + return true; + } + + @Override + public Joueur next() { + Joueur next = suivant; + if (opposants.equipe1.joueur1 == next) + { + suivant = opposants.equipe2.joueur1; + } + + else if (opposants.equipe2.joueur1 == next) + { + suivant = opposants.equipe1.joueur2; + } + + else if (opposants.equipe1.joueur2 == next) + { + suivant = opposants.equipe2.joueur2; + } + + else if (opposants.equipe2.joueur2 == next) + { + suivant = opposants.equipe1.joueur1; + } + + // suivant = suivant == opposants.joueurEsku.joueur1 ? opposants.joueurZaku.joueur1 : opposants.joueurEsku.joueur1; + return next; + } + } +} diff --git a/src/main/java/com/montaury/mus/jeu/joueur/AffichageConsoleEvenementsDeJeu.java b/src/main/java/com/montaury/mus/jeu/joueur/AffichageConsoleEvenementsDeJeu.java index a49e334..9f2daf2 100644 --- a/src/main/java/com/montaury/mus/jeu/joueur/AffichageConsoleEvenementsDeJeu.java +++ b/src/main/java/com/montaury/mus/jeu/joueur/AffichageConsoleEvenementsDeJeu.java @@ -2,8 +2,10 @@ import com.montaury.mus.jeu.Manche; import com.montaury.mus.jeu.Partie; +import com.montaury.mus.jeu.equipe.Opposants; import com.montaury.mus.jeu.tour.phases.Phase; import com.montaury.mus.jeu.tour.phases.dialogue.Choix; + import java.util.stream.Collectors; public class AffichageConsoleEvenementsDeJeu implements AffichageEvenementsDeJeu { @@ -31,7 +33,7 @@ public void mancheTerminee(Partie.Score score) { @Override public void nouveauTour(Opposants opposants) { - println(opposants.joueurEsku().nom() + " est esku"); + println(opposants.joueur1().nom() + " est esku"); } @Override diff --git a/src/main/java/com/montaury/mus/jeu/joueur/AffichageEvenementsDeJeu.java b/src/main/java/com/montaury/mus/jeu/joueur/AffichageEvenementsDeJeu.java index ec78dd7..00ebfad 100644 --- a/src/main/java/com/montaury/mus/jeu/joueur/AffichageEvenementsDeJeu.java +++ b/src/main/java/com/montaury/mus/jeu/joueur/AffichageEvenementsDeJeu.java @@ -2,6 +2,7 @@ import com.montaury.mus.jeu.Manche; import com.montaury.mus.jeu.Partie; +import com.montaury.mus.jeu.equipe.Opposants; import com.montaury.mus.jeu.tour.phases.Phase; import com.montaury.mus.jeu.tour.phases.dialogue.Choix; diff --git a/src/main/java/com/montaury/mus/jeu/joueur/Joueur.java b/src/main/java/com/montaury/mus/jeu/joueur/Joueur.java index 5391d57..5dcd2cd 100644 --- a/src/main/java/com/montaury/mus/jeu/joueur/Joueur.java +++ b/src/main/java/com/montaury/mus/jeu/joueur/Joueur.java @@ -8,8 +8,8 @@ public static Joueur humain(String nom) { return new Joueur(nom, new InterfaceJoueurHumain()); } - public static Joueur ordinateur() { - return new Joueur("Ordinateur", new InterfaceJoueurOrdinateur()); + public static Joueur ordinateur(String nom) { + return new Joueur(nom, new InterfaceJoueurOrdinateur()); } private final String nom; diff --git a/src/main/java/com/montaury/mus/jeu/joueur/Opposants.java b/src/main/java/com/montaury/mus/jeu/joueur/Opposants.java deleted file mode 100644 index 44f755b..0000000 --- a/src/main/java/com/montaury/mus/jeu/joueur/Opposants.java +++ /dev/null @@ -1,58 +0,0 @@ -package com.montaury.mus.jeu.joueur; - -import java.util.Iterator; -import java.util.List; - -public class Opposants { - private Joueur joueurEsku; - private Joueur joueurZaku; - - public Opposants(Joueur joueurEsku, Joueur joueurZaku) { - this.joueurEsku = joueurEsku; - this.joueurZaku = joueurZaku; - } - - public void tourner() { - Joueur tmp = joueurEsku; - joueurEsku = joueurZaku; - joueurZaku = tmp; - } - - public Joueur joueurEsku() { - return joueurEsku; - } - - public Joueur joueurZaku() { - return joueurZaku; - } - - public Iterator itererDansLOrdre() { - return new IteratorInfini(this); - } - - public List dansLOrdre() { - return List.of(joueurEsku, joueurZaku); - } - - private static class IteratorInfini implements Iterator { - private final Opposants opposants; - private Joueur suivant; - - public IteratorInfini(Opposants opposants) { - this.opposants = opposants; - suivant = opposants.joueurEsku; - } - - @Override - public boolean hasNext() { - return true; - } - - @Override - public Joueur next() { - Joueur next = suivant; - suivant = suivant == opposants.joueurEsku ? opposants.joueurZaku : opposants.joueurEsku; - return next; - } - } -} diff --git a/src/main/java/com/montaury/mus/jeu/tour/Tour.java b/src/main/java/com/montaury/mus/jeu/tour/Tour.java index 67bba0d..3f94f7a 100644 --- a/src/main/java/com/montaury/mus/jeu/tour/Tour.java +++ b/src/main/java/com/montaury/mus/jeu/tour/Tour.java @@ -4,7 +4,7 @@ import com.montaury.mus.jeu.carte.Defausse; import com.montaury.mus.jeu.carte.Paquet; import com.montaury.mus.jeu.joueur.AffichageEvenementsDeJeu; -import com.montaury.mus.jeu.joueur.Opposants; +import com.montaury.mus.jeu.equipe.Opposants; import com.montaury.mus.jeu.tour.phases.FauxJeu; import com.montaury.mus.jeu.tour.phases.Grand; import com.montaury.mus.jeu.tour.phases.Jeu; @@ -41,9 +41,10 @@ public void jouer(Opposants opposants, Manche.Score score) { ResultatsPhases resultats = new ResultatsPhases(); Iterator phases = phasesJouablesPar(opposants).iterator(); do { - Phase.Resultat resultat = phases.next().jouer(affichage, opposants, score); + Phase.Resultat resultat = phases.next().jouer(affichage, opposants, score);//bug lors des test resultats.ajouter(resultat); } while (phases.hasNext() && score.vainqueur().isEmpty()); + resultats.attribuerPointsRestants(score); } diff --git a/src/main/java/com/montaury/mus/jeu/tour/phases/FauxJeu.java b/src/main/java/com/montaury/mus/jeu/tour/phases/FauxJeu.java index fb0c8c4..de3fd0f 100644 --- a/src/main/java/com/montaury/mus/jeu/tour/phases/FauxJeu.java +++ b/src/main/java/com/montaury/mus/jeu/tour/phases/FauxJeu.java @@ -1,7 +1,7 @@ package com.montaury.mus.jeu.tour.phases; import com.montaury.mus.jeu.joueur.Joueur; -import com.montaury.mus.jeu.joueur.Opposants; +import com.montaury.mus.jeu.equipe.Opposants; import static com.montaury.mus.jeu.tour.phases.Jeu.aLeJeu; @@ -17,9 +17,27 @@ protected boolean peutParticiper(Joueur joueur) { @Override protected Joueur meilleurParmi(Opposants opposants) { - int pointsJoueurEsku = opposants.joueurEsku().main().pointsPourJeu(); - int pointsJoueurZaku = opposants.joueurZaku().main().pointsPourJeu(); - return pointsJoueurEsku >= pointsJoueurZaku ? opposants.joueurEsku() : opposants.joueurZaku(); + int pointsJoueurEsku = opposants.joueur1().main().pointsPourJeu(); + int pointsJoueurAllie = opposants.joueur3().main().pointsPourJeu(); + int pointsJoueurEnemie = opposants.joueur2().main().pointsPourJeu(); + int pointsJoueurZaku = opposants.joueur4().main().pointsPourJeu(); + + int pointsMeilleurJoueurEquipe1 = opposants.joueur1().main().pointsPourJeu(); + Joueur meilleurJoueurEquipe1 = opposants.joueur1(); + int pointsMeilleurJoueurEquipe2 = opposants.joueur4().main().pointsPourJeu(); + Joueur meilleurJoueurEquipe2 = opposants.joueur1(); + + if (pointsJoueurAllie > pointsJoueurEsku){ + pointsMeilleurJoueurEquipe1=pointsJoueurAllie; + meilleurJoueurEquipe1 = opposants.joueur2(); + } + if (pointsJoueurEnemie > pointsJoueurZaku){ + pointsMeilleurJoueurEquipe2=pointsJoueurEnemie; + meilleurJoueurEquipe2 = opposants.joueur3(); + } + + + return pointsMeilleurJoueurEquipe1 >= pointsMeilleurJoueurEquipe2 ? meilleurJoueurEquipe1 : meilleurJoueurEquipe2; } @Override diff --git a/src/main/java/com/montaury/mus/jeu/tour/phases/Grand.java b/src/main/java/com/montaury/mus/jeu/tour/phases/Grand.java index de7f7fb..bc14f45 100644 --- a/src/main/java/com/montaury/mus/jeu/tour/phases/Grand.java +++ b/src/main/java/com/montaury/mus/jeu/tour/phases/Grand.java @@ -4,11 +4,10 @@ import com.montaury.mus.jeu.carte.ValeurCarte; import com.montaury.mus.jeu.joueur.Joueur; import com.montaury.mus.jeu.joueur.Main; -import com.montaury.mus.jeu.joueur.Opposants; +import com.montaury.mus.jeu.equipe.Opposants; import java.util.List; -import static com.montaury.mus.jeu.carte.ValeurCarte.Comparaison.PLUS_GRANDE; -import static com.montaury.mus.jeu.carte.ValeurCarte.Comparaison.PLUS_PETITE; +import static com.montaury.mus.jeu.carte.ValeurCarte.Comparaison.*; public class Grand extends Phase { public Grand() { @@ -17,20 +16,59 @@ public Grand() { @Override protected Joueur meilleurParmi(Opposants opposants) { - Joueur joueurEsku = opposants.joueurEsku(); - Joueur joueurZaku = opposants.joueurZaku(); + Joueur joueurEsku = opposants.joueur1(); + Joueur joueur3 = opposants.joueur2(); + Joueur joueur2 = opposants.joueur3(); + Joueur joueurZaku = opposants.joueur4(); + Joueur joueurEquipe1Choisi = null; + Joueur joueurEquipe2Choisi = null; + Joueur joueurFinal=joueurEsku; + + List cartesJoueurEsku = joueurEsku.main().cartesDuPlusGrandAuPlusPetit(); + List cartesjoueur2 = joueur2.main().cartesDuPlusGrandAuPlusPetit(); + List cartesjoueur3 = joueur3.main().cartesDuPlusGrandAuPlusPetit(); List cartesJoueurZaku = joueurZaku.main().cartesDuPlusGrandAuPlusPetit(); + List cartesjoueurPlusGrandEquipe1 = null; + List cartesjoueurPlusGrandEquipe2 = null; + + for (int i = 0; i < Main.TAILLE; i++) { + ValeurCarte.Comparaison compareEquipe1 = cartesJoueurEsku.get(i).comparerAvec(cartesjoueur3.get(i)); + if (compareEquipe1 == PLUS_GRANDE) { + cartesjoueurPlusGrandEquipe1 = cartesJoueurEsku; + joueurEquipe1Choisi = joueurEsku; + break; + } else if (compareEquipe1 == PLUS_PETITE) { + cartesjoueurPlusGrandEquipe1 = cartesjoueur3; + joueurEquipe1Choisi = joueur3; + break; + } + } + for (int i = 0; i < Main.TAILLE; i++) { - ValeurCarte.Comparaison compare = cartesJoueurEsku.get(i).comparerAvec(cartesJoueurZaku.get(i)); - if (compare == PLUS_GRANDE) { - return joueurEsku; + ValeurCarte.Comparaison compareEquipe2 = cartesjoueur2.get(i).comparerAvec(cartesJoueurZaku.get(i)); + if (compareEquipe2 == PLUS_GRANDE) { + cartesjoueurPlusGrandEquipe2 = cartesjoueur2; + joueurEquipe2Choisi = joueur2; + break; + } else if (compareEquipe2 == PLUS_PETITE) { + cartesjoueurPlusGrandEquipe2 = cartesJoueurZaku; + joueurEquipe2Choisi = joueurZaku; + break; } - if (compare == PLUS_PETITE) { - return joueurZaku; + } + for (int i = 0; i < Main.TAILLE; i++) { + ValeurCarte.Comparaison compareEntreEquipe = cartesjoueurPlusGrandEquipe1.get(i).comparerAvec(cartesjoueurPlusGrandEquipe2.get(i)); + if (compareEntreEquipe == PLUS_GRANDE ) { + joueurFinal= joueurEquipe1Choisi; + break; + } else if (compareEntreEquipe == PLUS_PETITE) { + joueurFinal= joueurEquipe2Choisi; + break; + } } - return joueurEsku; + return joueurFinal; } } diff --git a/src/main/java/com/montaury/mus/jeu/tour/phases/Jeu.java b/src/main/java/com/montaury/mus/jeu/tour/phases/Jeu.java index 277aa64..7f7957b 100644 --- a/src/main/java/com/montaury/mus/jeu/tour/phases/Jeu.java +++ b/src/main/java/com/montaury/mus/jeu/tour/phases/Jeu.java @@ -1,7 +1,7 @@ package com.montaury.mus.jeu.tour.phases; import com.montaury.mus.jeu.joueur.Joueur; -import com.montaury.mus.jeu.joueur.Opposants; +import com.montaury.mus.jeu.equipe.Opposants; import java.util.List; public class Jeu extends Phase { @@ -23,9 +23,9 @@ protected boolean peutParticiper(Joueur joueur) { @Override protected Joueur meilleurParmi(Opposants opposants) { - return rangDuJeu(opposants.joueurEsku()) <= rangDuJeu(opposants.joueurZaku()) ? - opposants.joueurEsku() : - opposants.joueurZaku(); + return rangDuJeu(opposants.joueur1()) <= rangDuJeu(opposants.joueur4()) ? + opposants.joueur1() : + opposants.joueur4(); } private int rangDuJeu(Joueur joueur) { diff --git a/src/main/java/com/montaury/mus/jeu/tour/phases/Mus.java b/src/main/java/com/montaury/mus/jeu/tour/phases/Mus.java index 144fe59..36f79b1 100644 --- a/src/main/java/com/montaury/mus/jeu/tour/phases/Mus.java +++ b/src/main/java/com/montaury/mus/jeu/tour/phases/Mus.java @@ -5,10 +5,12 @@ import com.montaury.mus.jeu.carte.Paquet; import com.montaury.mus.jeu.joueur.AffichageEvenementsDeJeu; import com.montaury.mus.jeu.joueur.Joueur; -import com.montaury.mus.jeu.joueur.Opposants; +import com.montaury.mus.jeu.equipe.Opposants; import com.montaury.mus.jeu.tour.phases.dialogue.Mintza; import java.util.List; + + public class Mus { private final Paquet paquet; private final Defausse defausse; @@ -41,12 +43,18 @@ private void completerMain(AffichageEvenementsDeJeu affichage, Joueur joueur) { } private boolean veulentAllerMus(AffichageEvenementsDeJeu affichage, List joueurs) { + int indiceJoueur = 1; for (Joueur joueur : joueurs) { boolean mus = joueur.interfaceJoueur.veutAllerMus(); affichage.choixFait(joueur, mus ? new com.montaury.mus.jeu.tour.phases.dialogue.Mus() : new Mintza()); + if (indiceJoueur==3) + { + mus=true; + } if (!mus) { return false; } + indiceJoueur++; } return true; } diff --git a/src/main/java/com/montaury/mus/jeu/tour/phases/Paires.java b/src/main/java/com/montaury/mus/jeu/tour/phases/Paires.java index 863143e..0f84a15 100644 --- a/src/main/java/com/montaury/mus/jeu/tour/phases/Paires.java +++ b/src/main/java/com/montaury/mus/jeu/tour/phases/Paires.java @@ -1,7 +1,7 @@ package com.montaury.mus.jeu.tour.phases; import com.montaury.mus.jeu.joueur.Joueur; -import com.montaury.mus.jeu.joueur.Opposants; +import com.montaury.mus.jeu.equipe.Opposants; public class Paires extends Phase { public Paires() { @@ -15,9 +15,59 @@ protected boolean peutParticiper(Joueur joueur) { @Override protected Joueur meilleurParmi(Opposants opposants) { - com.montaury.mus.jeu.carte.paires.Paires pairesJoueurEsku = opposants.joueurEsku().main().getPaires(); - com.montaury.mus.jeu.carte.paires.Paires pairesJoueurZaku = opposants.joueurZaku().main().getPaires(); - return pairesJoueurEsku.estMeilleureOuEgaleA(pairesJoueurZaku) ? opposants.joueurEsku() : opposants.joueurZaku(); + + com.montaury.mus.jeu.carte.paires.Paires meilleurPaireEquie1; + com.montaury.mus.jeu.carte.paires.Paires meilleurPaireEquie2; + opposants.joueur1().main().getPaires(); + + Joueur meilleurJoueurEquipe1 = opposants.joueur1(); + Joueur meilleurJoueurEquipe2 = opposants.joueur4(); + + if(peutParticiper(opposants.joueur1()) && peutParticiper(opposants.joueur2())) + { + //recup le meilleur + if (opposants.joueur1().main().getPaires().estMeilleureOuEgaleA(opposants.joueur2().main().getPaires())){ + meilleurPaireEquie1=opposants.joueur1().main().getPaires(); + }else { + meilleurPaireEquie1=opposants.joueur2().main().getPaires(); + meilleurJoueurEquipe1=opposants.joueur2(); + } + } + else if(peutParticiper(opposants.joueur1())) + { + //recup paire esku + meilleurPaireEquie1 =opposants.joueur1().main().getPaires() ; + } + else + { + //recup paire j2e1 + meilleurPaireEquie1 =opposants.joueur2().main().getPaires() ; + meilleurJoueurEquipe1=opposants.joueur2(); + } + + if(peutParticiper(opposants.joueur4()) && peutParticiper(opposants.joueur3())) + { + //recup le meilleur + if (opposants.joueur4().main().getPaires().estMeilleureOuEgaleA(opposants.joueur2().main().getPaires())){ + meilleurPaireEquie2 =opposants.joueur4().main().getPaires(); + }else { + meilleurPaireEquie2=opposants.joueur3().main().getPaires(); + meilleurJoueurEquipe2=opposants.joueur3(); + } + } + else if(peutParticiper(opposants.joueur4())) + { + //recup paire zaku + meilleurPaireEquie2 =opposants.joueur4().main().getPaires() ; + } + else + { + //recup paire j1e2 + meilleurPaireEquie2 =opposants.joueur3().main().getPaires() ; + meilleurJoueurEquipe2=opposants.joueur3(); + } + + return meilleurPaireEquie1.estMeilleureOuEgaleA(meilleurPaireEquie2) ? meilleurJoueurEquipe1 : meilleurJoueurEquipe2; } @Override diff --git a/src/main/java/com/montaury/mus/jeu/tour/phases/Petit.java b/src/main/java/com/montaury/mus/jeu/tour/phases/Petit.java index a127fd5..4f6bfce 100644 --- a/src/main/java/com/montaury/mus/jeu/tour/phases/Petit.java +++ b/src/main/java/com/montaury/mus/jeu/tour/phases/Petit.java @@ -4,11 +4,10 @@ import com.montaury.mus.jeu.carte.ValeurCarte; import com.montaury.mus.jeu.joueur.Joueur; import com.montaury.mus.jeu.joueur.Main; -import com.montaury.mus.jeu.joueur.Opposants; +import com.montaury.mus.jeu.equipe.Opposants; import java.util.List; -import static com.montaury.mus.jeu.carte.ValeurCarte.Comparaison.PLUS_GRANDE; -import static com.montaury.mus.jeu.carte.ValeurCarte.Comparaison.PLUS_PETITE; +import static com.montaury.mus.jeu.carte.ValeurCarte.Comparaison.*; public class Petit extends Phase { public Petit() { @@ -17,20 +16,63 @@ public Petit() { @Override protected Joueur meilleurParmi(Opposants opposants) { - Joueur joueurEsku = opposants.joueurEsku(); - Joueur joueurZaku = opposants.joueurZaku(); + Joueur joueurEsku = opposants.joueur1(); + Joueur joueur3 = opposants.joueur2(); + Joueur joueur2 = opposants.joueur3(); + Joueur joueurZaku = opposants.joueur4(); + + Joueur joueurEquipe1Choisi = joueurEsku; + Joueur joueurEquipe2Choisi = joueur2; + + Joueur joueurFinal=joueurEsku; + List cartesJoueurEsku = joueurEsku.main().cartesDuPlusGrandAuPlusPetit(); + List cartesjoueur2 = joueur2.main().cartesDuPlusGrandAuPlusPetit(); + List cartesjoueur3 = joueur3.main().cartesDuPlusGrandAuPlusPetit(); List cartesJoueurZaku = joueurZaku.main().cartesDuPlusGrandAuPlusPetit(); + List cartesjoueurPlusGrandEquipe1 = null; + List cartesjoueurPlusGrandEquipe2 = null; + + for (int i = Main.TAILLE - 1; i >= 0; i--) { + ValeurCarte.Comparaison compareEquipe1 = cartesJoueurEsku.get(i).comparerAvec(cartesjoueur3.get(i)); + if (compareEquipe1 == PLUS_PETITE) { + cartesjoueurPlusGrandEquipe1 = cartesJoueurEsku; + joueurEquipe1Choisi = joueurEsku; + break; + } + if (compareEquipe1 == PLUS_GRANDE) { + cartesjoueurPlusGrandEquipe1 = cartesjoueur3; + joueurEquipe1Choisi = joueur3; + break; + } + } + for (int i = Main.TAILLE - 1; i >= 0; i--) { - ValeurCarte.Comparaison compare = cartesJoueurEsku.get(i).comparerAvec(cartesJoueurZaku.get(i)); - if (compare == PLUS_PETITE) { - return joueurEsku; + ValeurCarte.Comparaison compareEquipe2 = cartesjoueur2.get(i).comparerAvec(cartesJoueurZaku.get(i)); + if (compareEquipe2 == PLUS_PETITE) { + cartesjoueurPlusGrandEquipe2 = cartesjoueur2; + joueurEquipe2Choisi = joueur2; + break; + } else if (compareEquipe2 == PLUS_GRANDE) { + cartesjoueurPlusGrandEquipe2 = cartesJoueurZaku; + joueurEquipe2Choisi = joueurZaku; + break; } - if (compare == PLUS_GRANDE) { - return joueurZaku; + } + + for (int i = Main.TAILLE - 1; i >= 0; i--) { + ValeurCarte.Comparaison compareEntreEquipe = cartesjoueurPlusGrandEquipe1.get(i).comparerAvec(cartesjoueurPlusGrandEquipe2.get(i)); + if (compareEntreEquipe == PLUS_PETITE) { + joueurFinal= joueurEquipe1Choisi; + break; + } + else if (compareEntreEquipe == PLUS_GRANDE) { + joueurFinal= joueurEquipe2Choisi; + break; } } - return joueurEsku; + return joueurFinal; + } } diff --git a/src/main/java/com/montaury/mus/jeu/tour/phases/Phase.java b/src/main/java/com/montaury/mus/jeu/tour/phases/Phase.java index d5f5dbe..aef7278 100644 --- a/src/main/java/com/montaury/mus/jeu/tour/phases/Phase.java +++ b/src/main/java/com/montaury/mus/jeu/tour/phases/Phase.java @@ -1,9 +1,9 @@ package com.montaury.mus.jeu.tour.phases; import com.montaury.mus.jeu.Manche; +import com.montaury.mus.jeu.equipe.Opposants; import com.montaury.mus.jeu.joueur.AffichageEvenementsDeJeu; import com.montaury.mus.jeu.joueur.Joueur; -import com.montaury.mus.jeu.joueur.Opposants; import com.montaury.mus.jeu.tour.phases.dialogue.Dialogue; import com.montaury.mus.jeu.tour.phases.dialogue.DialogueTermine; import java.util.List; @@ -61,7 +61,7 @@ public List participantsParmi(Opposants opposants) { } public final boolean peutSeDerouler(Opposants opposants) { - return peutParticiper(opposants.joueurEsku()) && peutParticiper(opposants.joueurZaku()); + return (peutParticiper(opposants.joueur1()) || peutParticiper(opposants.joueur2())) && (peutParticiper(opposants.joueur4()) || peutParticiper(opposants.joueur3())); } protected boolean peutParticiper(Joueur joueur) { diff --git a/src/main/java/com/montaury/mus/jeu/tour/phases/dialogue/Dialogue.java b/src/main/java/com/montaury/mus/jeu/tour/phases/dialogue/Dialogue.java index 1a51487..0aef3f3 100644 --- a/src/main/java/com/montaury/mus/jeu/tour/phases/dialogue/Dialogue.java +++ b/src/main/java/com/montaury/mus/jeu/tour/phases/dialogue/Dialogue.java @@ -1,8 +1,9 @@ package com.montaury.mus.jeu.tour.phases.dialogue; +import com.montaury.mus.jeu.equipe.Opposants; import com.montaury.mus.jeu.joueur.AffichageEvenementsDeJeu; import com.montaury.mus.jeu.joueur.Joueur; -import com.montaury.mus.jeu.joueur.Opposants; +import com.montaury.mus.jeu.equipe.Opposants; import java.util.ArrayList; import java.util.Iterator; import java.util.List; diff --git a/src/test/java/com/montaury/mus/jeu/MancheTest.java b/src/test/java/com/montaury/mus/jeu/MancheTest.java index f87c58d..497774e 100644 --- a/src/test/java/com/montaury/mus/jeu/MancheTest.java +++ b/src/test/java/com/montaury/mus/jeu/MancheTest.java @@ -1,9 +1,10 @@ package com.montaury.mus.jeu; +import com.montaury.mus.jeu.equipe.Equipe; import com.montaury.mus.jeu.joueur.AffichageEvenementsDeJeu; import com.montaury.mus.jeu.joueur.InterfaceJoueur; import com.montaury.mus.jeu.joueur.Joueur; -import com.montaury.mus.jeu.joueur.Opposants; +import com.montaury.mus.jeu.equipe.Opposants; import com.montaury.mus.jeu.tour.phases.dialogue.Gehiago; import com.montaury.mus.jeu.tour.phases.dialogue.Hordago; import com.montaury.mus.jeu.tour.phases.dialogue.Imido; @@ -24,18 +25,29 @@ class MancheTest { @BeforeEach void setUp() { - interfaceJoueurEsku = mock(InterfaceJoueur.class); - interfaceJoueurZaku = mock(InterfaceJoueur.class); - joueurEsku = new Joueur("J1", interfaceJoueurEsku); - joueurZaku = new Joueur("J2", interfaceJoueurZaku); - opposants = new Opposants(joueurEsku, joueurZaku); + interfaceJoueur1 = mock(InterfaceJoueur.class); + interfaceJoueur2 = mock(InterfaceJoueur.class); + interfaceJoueur3 = mock(InterfaceJoueur.class); + interfaceJoueur4 = mock(InterfaceJoueur.class); + + joueur1 = new Joueur("J1", interfaceJoueur1); + joueur2 = new Joueur("J2", interfaceJoueur2); + joueur3 = new Joueur("J3", interfaceJoueur3); + joueur4 = new Joueur("J4", interfaceJoueur4); + + equipe1 = new Equipe(joueur1,joueur2); + equipe2 = new Equipe(joueur3,joueur4); + + opposants = new Opposants(equipe1, equipe2); manche = new Manche(mock(AffichageEvenementsDeJeu.class)); } @Test void devrait_terminer_la_manche_si_hordago_au_grand() { - when(interfaceJoueurEsku.faireChoixParmi(any())).thenReturn(new Hordago()); - when(interfaceJoueurZaku.faireChoixParmi(any())).thenReturn(new Kanta()); + when(interfaceJoueur1.faireChoixParmi(any())).thenReturn(new Hordago()); + when(interfaceJoueur2.faireChoixParmi(any())).thenReturn(new Kanta()); + when(interfaceJoueur3.faireChoixParmi(any())).thenReturn(new Kanta()); + when(interfaceJoueur4.faireChoixParmi(any())).thenReturn(new Kanta()); Manche.Resultat resultat = manche.jouer(opposants); @@ -45,29 +57,40 @@ void devrait_terminer_la_manche_si_hordago_au_grand() { @Test void devrait_terminer_la_manche_si_un_joueur_a_40_points() { - when(interfaceJoueurEsku.faireChoixParmi(any())).thenReturn(new Imido(), new Gehiago(2)); - when(interfaceJoueurZaku.faireChoixParmi(any())).thenReturn(new Gehiago(40), new Tira()); + when(interfaceJoueur1.faireChoixParmi(any())).thenReturn(new Imido(), new Gehiago(2)); + when(interfaceJoueur2.faireChoixParmi(any())).thenReturn(new Imido(), new Gehiago(2)); + when(interfaceJoueur3.faireChoixParmi(any())).thenReturn(new Imido(), new Gehiago(2)); + when(interfaceJoueur4.faireChoixParmi(any())).thenReturn(new Gehiago(40), new Tira()); Manche.Resultat resultat = manche.jouer(opposants); - assertThat(resultat.vainqueur()).isEqualTo(joueurEsku); + assertThat(resultat.vainqueur()).isEqualTo(joueur2); assertThat(resultat.pointsVaincu()).isZero(); } @Test void devrait_changer_l_ordre_des_opposants_a_la_fin_du_tour() { - when(interfaceJoueurEsku.faireChoixParmi(any())).thenReturn(new Hordago()); - when(interfaceJoueurZaku.faireChoixParmi(any())).thenReturn(new Kanta()); + + when(interfaceJoueur1.faireChoixParmi(any())).thenReturn(new Hordago()); + when(interfaceJoueur2.faireChoixParmi(any())).thenReturn(new Kanta()); + when(interfaceJoueur3.faireChoixParmi(any())).thenReturn(new Kanta()); + when(interfaceJoueur4.faireChoixParmi(any())).thenReturn(new Kanta()); manche.jouer(opposants); - assertThat(opposants.dansLOrdre()).containsExactly(joueurZaku, joueurEsku); + assertThat(opposants.dansLOrdre()).containsExactly(joueur4,joueur1,joueur3,joueur2); } - private InterfaceJoueur interfaceJoueurEsku; - private InterfaceJoueur interfaceJoueurZaku; - private Joueur joueurEsku; - private Joueur joueurZaku; + private InterfaceJoueur interfaceJoueur1; + private InterfaceJoueur interfaceJoueur2; + private InterfaceJoueur interfaceJoueur3; + private InterfaceJoueur interfaceJoueur4; + private Joueur joueur1; + private Joueur joueur2; + private Joueur joueur3; + private Joueur joueur4; + private Equipe equipe1; + private Equipe equipe2; private Opposants opposants; } \ No newline at end of file diff --git a/src/test/java/com/montaury/mus/jeu/PartieTest.java b/src/test/java/com/montaury/mus/jeu/PartieTest.java index a296e0e..d041301 100644 --- a/src/test/java/com/montaury/mus/jeu/PartieTest.java +++ b/src/test/java/com/montaury/mus/jeu/PartieTest.java @@ -1,9 +1,10 @@ package com.montaury.mus.jeu; +import com.montaury.mus.jeu.equipe.Equipe; import com.montaury.mus.jeu.joueur.AffichageEvenementsDeJeu; import com.montaury.mus.jeu.joueur.InterfaceJoueur; import com.montaury.mus.jeu.joueur.Joueur; -import com.montaury.mus.jeu.joueur.Opposants; +import com.montaury.mus.jeu.equipe.Opposants; import com.montaury.mus.jeu.tour.phases.dialogue.Hordago; import com.montaury.mus.jeu.tour.phases.dialogue.Kanta; import org.junit.jupiter.api.BeforeEach; @@ -18,18 +19,28 @@ class PartieTest { @BeforeEach void setUp() { - interfaceJoueurEsku = mock(InterfaceJoueur.class); - interfaceJoueurZaku = mock(InterfaceJoueur.class); - Joueur joueurEsku = new Joueur("J1", interfaceJoueurEsku); - Joueur joueurZaku = new Joueur("J2", interfaceJoueurZaku); - opposants = new Opposants(joueurEsku, joueurZaku); + interfaceJoueur1 = mock(InterfaceJoueur.class); + interfaceJoueur2 = mock(InterfaceJoueur.class); + interfaceJoueur3 = mock(InterfaceJoueur.class); + interfaceJoueur4 = mock(InterfaceJoueur.class); + joueur1 = new Joueur("J1", interfaceJoueur1); + joueur2 = new Joueur("J2", interfaceJoueur2); + joueur3 = new Joueur("J3", interfaceJoueur3); + joueur4 = new Joueur("J4", interfaceJoueur4); + + equipe1 = new Equipe(joueur1,joueur2); + equipe2 = new Equipe(joueur3,joueur4); + + opposants = new Opposants(equipe1, equipe2); partie = new Partie(mock(AffichageEvenementsDeJeu.class)); } @Test void devrait_faire_gagner_le_premier_joueur_a_3_manches() { - when(interfaceJoueurEsku.faireChoixParmi(any())).thenReturn(new Hordago()); - when(interfaceJoueurZaku.faireChoixParmi(any())).thenReturn(new Kanta()); + when(interfaceJoueur1.faireChoixParmi(any())).thenReturn(new Hordago()); + when(interfaceJoueur2.faireChoixParmi(any())).thenReturn(new Kanta()); + when(interfaceJoueur3.faireChoixParmi(any())).thenReturn(new Kanta()); + when(interfaceJoueur4.faireChoixParmi(any())).thenReturn(new Kanta()); Partie.Resultat resultat = partie.jouer(opposants); @@ -37,8 +48,16 @@ void devrait_faire_gagner_le_premier_joueur_a_3_manches() { assertThat(resultat.score().resultatManches()).hasSizeGreaterThanOrEqualTo(3); } - private InterfaceJoueur interfaceJoueurEsku; - private InterfaceJoueur interfaceJoueurZaku; + private InterfaceJoueur interfaceJoueur1; + private InterfaceJoueur interfaceJoueur2; + private InterfaceJoueur interfaceJoueur3; + private InterfaceJoueur interfaceJoueur4; + private Joueur joueur1; + private Joueur joueur2; + private Joueur joueur3; + private Joueur joueur4; + private Equipe equipe1; + private Equipe equipe2; private Opposants opposants; private Partie partie; } \ No newline at end of file diff --git a/src/test/java/com/montaury/mus/jeu/tour/TourTest.java b/src/test/java/com/montaury/mus/jeu/tour/TourTest.java index b5164f6..d6f917b 100644 --- a/src/test/java/com/montaury/mus/jeu/tour/TourTest.java +++ b/src/test/java/com/montaury/mus/jeu/tour/TourTest.java @@ -3,10 +3,11 @@ import com.montaury.mus.jeu.Manche; import com.montaury.mus.jeu.carte.Carte; import com.montaury.mus.jeu.carte.Defausse; +import com.montaury.mus.jeu.equipe.Equipe; import com.montaury.mus.jeu.joueur.AffichageEvenementsDeJeu; import com.montaury.mus.jeu.joueur.InterfaceJoueur; import com.montaury.mus.jeu.joueur.Joueur; -import com.montaury.mus.jeu.joueur.Opposants; +import com.montaury.mus.jeu.equipe.Opposants; import com.montaury.mus.jeu.tour.phases.dialogue.Gehiago; import com.montaury.mus.jeu.tour.phases.dialogue.Hordago; import com.montaury.mus.jeu.tour.phases.dialogue.Idoki; @@ -29,93 +30,130 @@ class TourTest { @BeforeEach void setUp() { interfaceJoueurEsku = mock(InterfaceJoueur.class); + interfacejoueurAmi = mock(InterfaceJoueur.class); + interfacejoueurEnemie = mock(InterfaceJoueur.class); interfaceJoueurZaku = mock(InterfaceJoueur.class); joueurEsku = new Joueur("J1", interfaceJoueurEsku); - joueurZaku = new Joueur("J2", interfaceJoueurZaku); - opposants = new Opposants(joueurEsku, joueurZaku); + joueurAmi = new Joueur("J2", interfaceJoueurZaku); + joueurEnemie = new Joueur("J3", interfaceJoueurZaku); + joueurZaku = new Joueur("J4", interfaceJoueurZaku); + equipe1= new Equipe(joueurEsku,joueurAmi); + equipe2=new Equipe( joueurEnemie,joueurZaku); + opposants = new Opposants(equipe1,equipe2); score = new Manche.Score(opposants); evenementsDeJeu = mock(AffichageEvenementsDeJeu.class); tour = new Tour(evenementsDeJeu, paquetEntierCroissant(), new Defausse()); } @Test - void devrait_donner_tous_les_points_au_joueur_esku_si_le_joueur_zaku_fait_tira() { + void devrait_donner_tous_les_points_au_joueur_1_si_tous_les_joueurs_font_tira() { when(interfaceJoueurEsku.faireChoixParmi(any())).thenReturn(new Imido()); when(interfaceJoueurZaku.faireChoixParmi(any())).thenReturn(new Tira()); + when(interfacejoueurAmi.faireChoixParmi(any())).thenReturn(new Tira()); + when(interfacejoueurEnemie.faireChoixParmi(any())).thenReturn(new Tira()); tour.jouer(opposants, score); assertThat(score.vainqueur()).isEmpty(); assertThat(score.scoreParJoueur()).containsEntry(joueurEsku, 8); assertThat(score.scoreParJoueur()).containsEntry(joueurZaku, 0); + assertThat(score.scoreParJoueur()).containsEntry(joueurAmi, 0); + assertThat(score.scoreParJoueur()).containsEntry(joueurEnemie, 0); } @Test void devrait_repartir_les_points_si_tout_est_paso() { when(interfaceJoueurEsku.faireChoixParmi(any())).thenReturn(new Paso()); when(interfaceJoueurZaku.faireChoixParmi(any())).thenReturn(new Paso()); - + when(interfacejoueurAmi.faireChoixParmi(any())).thenReturn(new Paso()); + when(interfacejoueurEnemie.faireChoixParmi(any())).thenReturn(new Paso()); tour.jouer(opposants, score); assertThat(score.vainqueur()).isEmpty(); - assertThat(score.scoreParJoueur()).containsEntry(joueurEsku, 1); - assertThat(score.scoreParJoueur()).containsEntry(joueurZaku, 5); + assertThat(score.scoreParJoueur()).containsEntry(joueurEsku, 2); + assertThat(score.scoreParJoueur()).containsEntry(joueurAmi, 0); + assertThat(score.scoreParJoueur()).containsEntry(joueurEnemie, 0); + assertThat(score.scoreParJoueur()).containsEntry(joueurZaku, 4); } @Test void devrait_faire_gagner_le_joueur_zaku_si_hordago_au_grand() { when(interfaceJoueurEsku.faireChoixParmi(any())).thenReturn(new Hordago()); when(interfaceJoueurZaku.faireChoixParmi(any())).thenReturn(new Kanta()); - + when(interfacejoueurAmi.faireChoixParmi(any())).thenReturn(new Kanta()); + when(interfacejoueurEnemie.faireChoixParmi(any())).thenReturn(new Kanta()); tour.jouer(opposants, score); assertThat(score.vainqueur()).contains(joueurZaku); assertThat(score.scoreParJoueur()).containsEntry(joueurEsku, 0); assertThat(score.scoreParJoueur()).containsEntry(joueurZaku, 40); + assertThat(score.scoreParJoueur()).containsEntry(joueurAmi, 0); + assertThat(score.scoreParJoueur()).containsEntry(joueurEnemie, 0); } @Test void devrait_partager_les_points_si_tout_est_idoki() { when(interfaceJoueurEsku.faireChoixParmi(any())).thenReturn(new Imido()); when(interfaceJoueurZaku.faireChoixParmi(any())).thenReturn(new Idoki()); + when(interfacejoueurAmi.faireChoixParmi(any())).thenReturn(new Idoki()); + when(interfacejoueurEnemie.faireChoixParmi(any())).thenReturn(new Idoki()); + //24point en tous tour.jouer(opposants, score); assertThat(score.vainqueur()).isEmpty(); - assertThat(score.scoreParJoueur()).containsEntry(joueurEsku, 2); - assertThat(score.scoreParJoueur()).containsEntry(joueurZaku, 10); + assertThat(score.scoreParJoueur()).containsEntry(joueurEsku, 5); + assertThat(score.scoreParJoueur()).containsEntry(joueurZaku, 7); + assertThat(score.scoreParJoueur()).containsEntry(joueurAmi, 0); + assertThat(score.scoreParJoueur()).containsEntry(joueurEnemie, 0); } @Test void devrait_partager_les_points_si_tout_est_gehiago_puis_idoki() { when(interfaceJoueurEsku.faireChoixParmi(any())).thenReturn(new Imido(), new Idoki(), new Imido(), new Idoki(), new Imido(), new Idoki(), new Imido(), new Idoki()); when(interfaceJoueurZaku.faireChoixParmi(any())).thenReturn(new Gehiago(2)); + when(interfacejoueurAmi.faireChoixParmi(any())).thenReturn(new Gehiago(2)); + when(interfacejoueurEnemie.faireChoixParmi(any())).thenReturn(new Gehiago(2)); + tour.jouer(opposants, score); assertThat(score.vainqueur()).isEmpty(); - assertThat(score.scoreParJoueur()).containsEntry(joueurEsku, 4); - assertThat(score.scoreParJoueur()).containsEntry(joueurZaku, 16); + assertThat(score.scoreParJoueur()).containsEntry(joueurEsku, 17); + assertThat(score.scoreParJoueur()).containsEntry(joueurZaku, 19); + assertThat(score.scoreParJoueur()).containsEntry(joueurAmi, 0); + assertThat(score.scoreParJoueur()).containsEntry(joueurEnemie, 0); } @Test void devrait_privilegier_le_joueur_esku_si_les_mains_sont_identiques() { when(interfaceJoueurEsku.faireChoixParmi(any())).thenReturn(new Imido()); when(interfaceJoueurZaku.faireChoixParmi(any())).thenReturn(new Idoki()); + when(interfacejoueurAmi.faireChoixParmi(any())).thenReturn(new Idoki()); + when(interfacejoueurEnemie.faireChoixParmi(any())).thenReturn(new Idoki()); - Tour tour = new Tour(evenementsDeJeu, paquetAvec(Carte.AS_BATON, Carte.DEUX_BATON, Carte.TROIS_BATON, Carte.QUATRE_BATON, Carte.AS_COUPE, Carte.DEUX_COUPE, Carte.TROIS_COUPE, Carte.QUATRE_COUPE), new Defausse()); - + Tour tour = new Tour(evenementsDeJeu, paquetAvec(Carte.AS_BATON, Carte.DEUX_BATON, Carte.TROIS_BATON, Carte.QUATRE_BATON, + Carte.CINQ_COUPE, Carte.SIX_EPEE, Carte.SEPT_BATON, Carte.VALET_PIECE, + Carte.CINQ_COUPE, Carte.SIX_EPEE, Carte.SEPT_BATON, Carte.VALET_PIECE, + Carte.AS_COUPE, Carte.DEUX_COUPE, Carte.TROIS_COUPE, Carte.QUATRE_COUPE), new Defausse()); tour.jouer(opposants, score); - assertThat(score.vainqueur()).isEmpty(); - assertThat(score.scoreParJoueur()).containsEntry(joueurEsku, 7); + assertThat(score.scoreParJoueur()).containsEntry(joueurEsku, 4); assertThat(score.scoreParJoueur()).containsEntry(joueurZaku, 0); + assertThat(score.scoreParJoueur()).containsEntry(joueurAmi, 3); + assertThat(score.scoreParJoueur()).containsEntry(joueurEnemie, 0); } private InterfaceJoueur interfaceJoueurEsku; private InterfaceJoueur interfaceJoueurZaku; + private InterfaceJoueur interfacejoueurAmi; + private InterfaceJoueur interfacejoueurEnemie; private Joueur joueurEsku; private Joueur joueurZaku; + private Joueur joueurAmi; + private Joueur joueurEnemie; + Equipe equipe1; + Equipe equipe2; private Opposants opposants; private Manche.Score score; private AffichageEvenementsDeJeu evenementsDeJeu; diff --git a/src/test/java/com/montaury/mus/jeu/tour/phases/FauxJeuTest.java b/src/test/java/com/montaury/mus/jeu/tour/phases/FauxJeuTest.java index f8d93ff..25c3a90 100644 --- a/src/test/java/com/montaury/mus/jeu/tour/phases/FauxJeuTest.java +++ b/src/test/java/com/montaury/mus/jeu/tour/phases/FauxJeuTest.java @@ -1,8 +1,9 @@ package com.montaury.mus.jeu.tour.phases; import com.montaury.mus.jeu.carte.Carte; +import com.montaury.mus.jeu.equipe.Equipe; import com.montaury.mus.jeu.joueur.Joueur; -import com.montaury.mus.jeu.joueur.Opposants; +import com.montaury.mus.jeu.equipe.Opposants; import org.junit.jupiter.api.Test; import static com.montaury.mus.jeu.joueur.Fixtures.main; @@ -11,10 +12,12 @@ class FauxJeuTest { @Test - void ne_doit_pas_se_derouler_si_un_seul_des_joueurs_a_le_jeu() { + void ne_doit_pas_se_derouler_si_un_equipe_a_que_du_jeu() { Opposants opposants = new Opposants( - unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)), - unJoueurAvec(main(Carte.VALET_PIECE, Carte.CAVALIER_PIECE, Carte.ROI_BATON, Carte.AS_PIECE)) + new Equipe( unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)), + unJoueurAvec(main(Carte.AS_COUPE, Carte.DEUX_COUPE, Carte.TROIS_COUPE, Carte.QUATRE_COUPE))), + new Equipe( unJoueurAvec(main(Carte.VALET_PIECE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.QUATRE_EPEE)), + unJoueurAvec(main(Carte.VALET_PIECE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.AS_EPEE))) ); boolean peutSeDerouler = new FauxJeu().peutSeDerouler(opposants); @@ -25,8 +28,10 @@ void ne_doit_pas_se_derouler_si_un_seul_des_joueurs_a_le_jeu() { @Test void doit_se_derouler_si_personne_n_a_le_jeu() { Opposants opposants = new Opposants( - unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)), - unJoueurAvec(main(Carte.VALET_PIECE, Carte.SIX_PIECE, Carte.QUATRE_BATON, Carte.AS_PIECE)) + new Equipe( unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)), + unJoueurAvec(main(Carte.AS_COUPE, Carte.DEUX_COUPE, Carte.TROIS_COUPE, Carte.QUATRE_COUPE))), + new Equipe( unJoueurAvec(main(Carte.AS_EPEE, Carte.DEUX_EPEE, Carte.TROIS_EPEE, Carte.QUATRE_EPEE)), + unJoueurAvec(main(Carte.AS_PIECE, Carte.DEUX_PIECE, Carte.TROIS_PIECE, Carte.QUATRE_BATON))) ); boolean peutSeDerouler = new FauxJeu().peutSeDerouler(opposants); @@ -36,28 +41,32 @@ void doit_se_derouler_si_personne_n_a_le_jeu() { @Test void devrait_faire_gagner_le_joueur_ayant_le_plus_grand_nombre_de_points() { - Joueur joueurZaku = unJoueurAvec(main(Carte.VALET_PIECE, Carte.SIX_PIECE, Carte.QUATRE_BATON, Carte.ROI_COUPE)); + Joueur joueur1 = unJoueurAvec(main(Carte.VALET_PIECE, Carte.SIX_PIECE, Carte.QUATRE_BATON, Carte.ROI_COUPE)); Opposants opposants = new Opposants( - unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)), - joueurZaku + new Equipe( joueur1, + unJoueurAvec(main(Carte.AS_COUPE, Carte.DEUX_COUPE, Carte.TROIS_COUPE, Carte.QUATRE_COUPE))), + new Equipe( unJoueurAvec(main(Carte.AS_EPEE, Carte.DEUX_EPEE, Carte.TROIS_EPEE, Carte.QUATRE_EPEE)), + unJoueurAvec(main(Carte.AS_PIECE, Carte.DEUX_PIECE, Carte.TROIS_PIECE, Carte.QUATRE_BATON))) ); Joueur vainqueur = new FauxJeu().meilleurParmi(opposants); - assertThat(vainqueur).isEqualTo(joueurZaku); + assertThat(vainqueur).isEqualTo(joueur1); } @Test void devrait_faire_gagner_le_joueur_esku_en_cas_d_egalite() { - Joueur joueurEsku = unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)); + Joueur joueur1 = unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)); + Joueur joueur2 =unJoueurAvec(main(Carte.AS_PIECE, Carte.QUATRE_BATON, Carte.VALET_COUPE, Carte.SIX_BATON)); + Joueur joueur3 =unJoueurAvec(main(Carte.AS_EPEE, Carte.QUATRE_EPEE, Carte.VALET_EPEE, Carte.SIX_EPEE)); + Joueur joueur4 = unJoueurAvec(main(Carte.AS_COUPE, Carte.QUATRE_COUPE, Carte.VALET_PIECE, Carte.SIX_PIECE)); Opposants opposants = new Opposants( - joueurEsku, - unJoueurAvec(main(Carte.VALET_PIECE, Carte.SIX_PIECE, Carte.QUATRE_BATON, Carte.AS_PIECE)) - ); + new Equipe( joueur1,joueur2), + new Equipe(joueur3 ,joueur4)); Joueur vainqueur = new FauxJeu().meilleurParmi(opposants); - assertThat(vainqueur).isEqualTo(joueurEsku); + assertThat(vainqueur).isEqualTo(joueur1); } @Test diff --git a/src/test/java/com/montaury/mus/jeu/tour/phases/GrandTest.java b/src/test/java/com/montaury/mus/jeu/tour/phases/GrandTest.java index cd12cf4..7368210 100644 --- a/src/test/java/com/montaury/mus/jeu/tour/phases/GrandTest.java +++ b/src/test/java/com/montaury/mus/jeu/tour/phases/GrandTest.java @@ -1,8 +1,9 @@ package com.montaury.mus.jeu.tour.phases; import com.montaury.mus.jeu.carte.Carte; +import com.montaury.mus.jeu.equipe.Equipe; +import com.montaury.mus.jeu.equipe.Opposants; import com.montaury.mus.jeu.joueur.Joueur; -import com.montaury.mus.jeu.joueur.Opposants; import org.junit.jupiter.api.Test; import static com.montaury.mus.jeu.joueur.Fixtures.main; @@ -11,41 +12,79 @@ class GrandTest { @Test - void devrait_faire_gagner_le_joueur_esku_s_il_a_la_plus_grande_carte() { - Joueur joueurEsku = unJoueurAvec(main(Carte.AS_BATON, Carte.CINQ_PIECE, Carte.CAVALIER_BATON, Carte.SIX_COUPE)); - Joueur joueurZaku = unJoueurAvec(main(Carte.DEUX_BATON, Carte.TROIS_PIECE, Carte.SEPT_BATON, Carte.AS_PIECE)); + void devrait_faire_gagner_le_joueur_4_s_il_a_la_plus_grande_carte() { + Joueur joueur1 = unJoueurAvec(main(Carte.DEUX_PIECE, Carte.CINQ_PIECE, Carte.SEPT_BATON, Carte.AS_COUPE)); + Joueur joueur2 = unJoueurAvec(main(Carte.DEUX_BATON, Carte.DEUX_BATON, Carte.CAVALIER_BATON, Carte.SIX_BATON)); + Joueur joueur3 = unJoueurAvec(main(Carte.TROIS_EPEE, Carte.CINQ_EPEE, Carte.SEPT_EPEE, Carte.VALET_EPEE)); + Joueur joueur4 = unJoueurAvec(main(Carte.ROI_PIECE, Carte.TROIS_PIECE, Carte.CAVALIER_PIECE, Carte.SIX_PIECE)); + Equipe equipe1 = new Equipe(joueur1,joueur2); + Equipe equipe2 = new Equipe(joueur3,joueur4); - Joueur vainqueur = new Grand().meilleurParmi(new Opposants(joueurEsku, joueurZaku)); + Joueur vainqueur = new Grand().meilleurParmi(new Opposants(equipe1, equipe2)); + assertThat(vainqueur).isEqualTo(joueur4); + } + @Test + void devrait_faire_gagner_le_joueur_3_s_il_a_la_plus_grande_carte() { + Joueur joueur1 = unJoueurAvec(main(Carte.DEUX_PIECE, Carte.CINQ_PIECE, Carte.SEPT_BATON, Carte.AS_COUPE)); + Joueur joueur2 = unJoueurAvec(main(Carte.DEUX_BATON, Carte.DEUX_BATON, Carte.CAVALIER_BATON, Carte.SIX_BATON)); + Joueur joueur3 = unJoueurAvec(main(Carte.ROI_PIECE, Carte.CINQ_EPEE, Carte.SEPT_EPEE, Carte.VALET_EPEE)); + Joueur joueur4 = unJoueurAvec(main(Carte.TROIS_EPEE, Carte.TROIS_PIECE, Carte.CAVALIER_PIECE, Carte.SIX_PIECE)); + Equipe equipe1 = new Equipe(joueur1,joueur2); + Equipe equipe2 = new Equipe(joueur3,joueur4); - assertThat(vainqueur).isEqualTo(joueurEsku); + Joueur vainqueur = new Grand().meilleurParmi(new Opposants(equipe1, equipe2)); + assertThat(vainqueur).isEqualTo(joueur3); } @Test - void devrait_faire_gagner_le_joueur_zaku_s_il_a_la_plus_grande_carte() { - Joueur joueurEsku = unJoueurAvec(main(Carte.AS_BATON, Carte.CINQ_PIECE, Carte.SEPT_BATON, Carte.SIX_COUPE)); - Joueur joueurZaku = unJoueurAvec(main(Carte.DEUX_BATON, Carte.TROIS_PIECE, Carte.CAVALIER_BATON, Carte.AS_PIECE)); + void devrait_faire_gagner_le_joueur_2_s_il_a_la_plus_grande_carte() { + Joueur joueur1 = unJoueurAvec(main(Carte.DEUX_PIECE, Carte.CINQ_PIECE, Carte.SEPT_BATON, Carte.AS_COUPE)); + Joueur joueur2 = unJoueurAvec(main(Carte.ROI_PIECE, Carte.DEUX_BATON, Carte.CAVALIER_BATON, Carte.SIX_BATON)); + Joueur joueur3 = unJoueurAvec(main(Carte.TROIS_EPEE, Carte.CINQ_EPEE, Carte.SEPT_EPEE, Carte.VALET_EPEE)); + Joueur joueur4 = unJoueurAvec(main(Carte.DEUX_COUPE, Carte.TROIS_PIECE, Carte.CAVALIER_PIECE, Carte.SIX_PIECE)); + Equipe equipe1 = new Equipe(joueur1,joueur2); + Equipe equipe2 = new Equipe(joueur3,joueur4); - Joueur vainqueur = new Grand().meilleurParmi(new Opposants(joueurEsku, joueurZaku)); + Joueur vainqueur = new Grand().meilleurParmi(new Opposants(equipe1, equipe2)); + assertThat(vainqueur).isEqualTo(joueur2); + } + @Test + void devrait_faire_gagner_le_joueur_1_s_il_a_la_plus_grande_carte() { + Joueur joueur1 = unJoueurAvec(main(Carte.ROI_PIECE, Carte.CINQ_PIECE, Carte.SEPT_BATON, Carte.AS_COUPE)); + Joueur joueur2 = unJoueurAvec(main(Carte.DEUX_BATON, Carte.DEUX_BATON, Carte.CAVALIER_BATON, Carte.SIX_BATON)); + Joueur joueur3 = unJoueurAvec(main(Carte.TROIS_EPEE, Carte.CINQ_EPEE, Carte.SEPT_EPEE, Carte.VALET_EPEE)); + Joueur joueur4 = unJoueurAvec(main(Carte.DEUX_PIECE, Carte.TROIS_PIECE, Carte.CAVALIER_PIECE, Carte.SIX_PIECE)); + Equipe equipe1 = new Equipe(joueur1,joueur2); + Equipe equipe2 = new Equipe(joueur3,joueur4); - assertThat(vainqueur).isEqualTo(joueurZaku); + Joueur vainqueur = new Petit().meilleurParmi(new Opposants(equipe1, equipe2)); + assertThat(vainqueur).isEqualTo(joueur1); } @Test void devrait_faire_gagner_le_joueur_qui_a_la_seconde_plus_grande_carte_si_la_premiere_est_egale() { - Joueur joueurEsku = unJoueurAvec(main(Carte.AS_BATON, Carte.CINQ_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)); - Joueur joueurZaku = unJoueurAvec(main(Carte.DEUX_BATON, Carte.VALET_PIECE, Carte.QUATRE_BATON, Carte.SEPT_PIECE)); + Joueur joueur1 = unJoueurAvec(main(Carte.ROI_PIECE, Carte.CINQ_PIECE, Carte.SEPT_BATON, Carte.AS_COUPE)); + Joueur joueur2 = unJoueurAvec(main(Carte.DEUX_BATON, Carte.DEUX_BATON, Carte.CAVALIER_BATON, Carte.SIX_BATON)); + Joueur joueur3 = unJoueurAvec(main(Carte.TROIS_EPEE, Carte.CINQ_EPEE, Carte.SEPT_EPEE, Carte.VALET_EPEE)); + Joueur joueur4 = unJoueurAvec(main(Carte.ROI_BATON, Carte.TROIS_PIECE, Carte.CAVALIER_PIECE, Carte.SIX_PIECE)); + Equipe equipe1 = new Equipe(joueur1,joueur2); + Equipe equipe2 = new Equipe(joueur3,joueur4); - Joueur vainqueur = new Grand().meilleurParmi(new Opposants(joueurEsku, joueurZaku)); + Joueur vainqueur = new Grand().meilleurParmi(new Opposants(equipe1, equipe2)); - assertThat(vainqueur).isEqualTo(joueurZaku); + assertThat(vainqueur).isEqualTo(joueur4); } @Test - void devrait_faire_gagner_le_joueur_esku_si_les_deux_mains_sont_egales() { - Joueur joueurEsku = unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)); - Joueur joueurZaku = unJoueurAvec(main(Carte.VALET_PIECE, Carte.SIX_PIECE, Carte.QUATRE_BATON, Carte.AS_PIECE)); + void devrait_faire_gagner_le_joueur_esku_si_les_quatre_mains_sont_egales() { + Joueur joueur1 = unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)); + Joueur joueur2 = unJoueurAvec(main(Carte.AS_EPEE, Carte.AS_EPEE, Carte.AS_EPEE, Carte.AS_EPEE)); + Joueur joueur3 = unJoueurAvec(main(Carte.AS_EPEE, Carte.AS_EPEE, Carte.AS_EPEE, Carte.AS_EPEE)); + Joueur joueur4 = unJoueurAvec(main(Carte.AS_COUPE, Carte.QUATRE_EPEE, Carte.VALET_EPEE, Carte.SIX_BATON)); + Equipe equipe1 = new Equipe(joueur1,joueur2); + Equipe equipe2 = new Equipe(joueur3,joueur4); - Joueur vainqueur = new Grand().meilleurParmi(new Opposants(joueurEsku, joueurZaku)); + Joueur vainqueur = new Grand().meilleurParmi(new Opposants(equipe1, equipe2)); - assertThat(vainqueur).isEqualTo(joueurEsku); + assertThat(vainqueur).isEqualTo(joueur1); } } \ No newline at end of file diff --git a/src/test/java/com/montaury/mus/jeu/tour/phases/JeuTest.java b/src/test/java/com/montaury/mus/jeu/tour/phases/JeuTest.java index 0401a8a..36953d2 100644 --- a/src/test/java/com/montaury/mus/jeu/tour/phases/JeuTest.java +++ b/src/test/java/com/montaury/mus/jeu/tour/phases/JeuTest.java @@ -1,8 +1,9 @@ package com.montaury.mus.jeu.tour.phases; import com.montaury.mus.jeu.carte.Carte; +import com.montaury.mus.jeu.equipe.Equipe; import com.montaury.mus.jeu.joueur.Joueur; -import com.montaury.mus.jeu.joueur.Opposants; +import com.montaury.mus.jeu.equipe.Opposants; import org.junit.jupiter.api.Test; import static com.montaury.mus.jeu.joueur.Fixtures.main; @@ -13,8 +14,10 @@ class JeuTest { @Test void ne_doit_pas_se_derouler_si_personne_n_a_le_jeu() { Opposants opposants = new Opposants( - unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)), - unJoueurAvec(main(Carte.VALET_PIECE, Carte.SIX_PIECE, Carte.QUATRE_BATON, Carte.AS_PIECE)) + new Equipe( unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)), + unJoueurAvec(main(Carte.AS_COUPE, Carte.DEUX_COUPE, Carte.TROIS_COUPE, Carte.QUATRE_COUPE))), + new Equipe( unJoueurAvec(main(Carte.AS_EPEE, Carte.DEUX_EPEE, Carte.TROIS_EPEE, Carte.QUATRE_EPEE)), + unJoueurAvec(main(Carte.AS_PIECE, Carte.DEUX_PIECE, Carte.TROIS_PIECE, Carte.QUATRE_BATON))) ); boolean peutSeDerouler = new Jeu().peutSeDerouler(opposants); @@ -23,10 +26,12 @@ void ne_doit_pas_se_derouler_si_personne_n_a_le_jeu() { } @Test - void ne_doit_pas_se_derouler_si_un_des_joueurs_n_a_pas_le_jeu() { + void ne_doit_pas_se_derouler_si_une_des_deux_equipe_n_a_pas_le_jeu() { Opposants opposants = new Opposants( - unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)), - unJoueurAvec(main(Carte.VALET_PIECE, Carte.CAVALIER_PIECE, Carte.ROI_BATON, Carte.AS_PIECE)) + new Equipe( unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)), + unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.AS_PIECE))), + new Equipe( unJoueurAvec(main(Carte.VALET_PIECE, Carte.ROI_BATON, Carte.CAVALIER_EPEE, Carte.AS_COUPE)), + unJoueurAvec(main(Carte.VALET_PIECE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.AS_EPEE))) ); boolean peutSeDerouler = new Jeu().peutSeDerouler(opposants); @@ -35,10 +40,12 @@ void ne_doit_pas_se_derouler_si_un_des_joueurs_n_a_pas_le_jeu() { } @Test - void devrait_se_derouler_si_les_deux_joueurs_ont_le_jeu() { + void devrait_se_derouler_si_tous_les_joueurs_ont_le_jeu() { Opposants opposants = new Opposants( - unJoueurAvec(main(Carte.SIX_COUPE, Carte.SEPT_EPEE, Carte.VALET_BATON, Carte.VALET_COUPE)), - unJoueurAvec(main(Carte.VALET_PIECE, Carte.CAVALIER_PIECE, Carte.ROI_BATON, Carte.AS_PIECE)) + new Equipe( unJoueurAvec(main(Carte.VALET_EPEE, Carte.ROI_COUPE, Carte.VALET_BATON, Carte.SIX_COUPE)), + unJoueurAvec(main(Carte.VALET_PIECE, Carte.ROI_EPEE, Carte.CAVALIER_COUPE, Carte.AS_PIECE))), + new Equipe( unJoueurAvec(main(Carte.VALET_BATON, Carte.ROI_BATON, Carte.CAVALIER_EPEE, Carte.AS_COUPE)), + unJoueurAvec(main(Carte.VALET_COUPE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.AS_EPEE))) ); boolean peutSeDerouler = new Jeu().peutSeDerouler(opposants); @@ -48,58 +55,70 @@ void devrait_se_derouler_si_les_deux_joueurs_ont_le_jeu() { @Test void devrait_faire_gagner_le_joueur_ayant_31_par_rapport_a_32() { - Joueur joueurEsku = unJoueurAvec(main(Carte.SIX_COUPE, Carte.ROI_EPEE, Carte.VALET_BATON, Carte.SIX_BATON)); - Joueur joueurZaku = unJoueurAvec(main(Carte.VALET_PIECE, Carte.CAVALIER_PIECE, Carte.ROI_BATON, Carte.AS_PIECE)); - - Joueur vainqueur = new Jeu().meilleurParmi(new Opposants(joueurEsku, joueurZaku)); - - assertThat(vainqueur).isEqualTo(joueurZaku); + Joueur joueur1 = unJoueurAvec(main(Carte.VALET_COUPE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.AS_EPEE)); + Joueur joueur2 = unJoueurAvec(main(Carte.VALET_COUPE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.DEUX_PIECE)); + Joueur joueur3 = unJoueurAvec(main(Carte.VALET_COUPE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.DEUX_EPEE)); + Joueur joueur4 = unJoueurAvec(main(Carte.VALET_COUPE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.DEUX_BATON)); + Equipe equipe1 = new Equipe(joueur1,joueur2); + Equipe equipe2 = new Equipe(joueur3,joueur4); + + Joueur vainqueur = new Jeu().meilleurParmi(new Opposants(equipe1, equipe2)); + assertThat(vainqueur).isEqualTo(joueur1); } @Test void devrait_faire_gagner_le_joueur_ayant_40_par_rapport_a_37() { - Joueur joueurEsku = unJoueurAvec(main(Carte.SEPT_BATON, Carte.ROI_EPEE, Carte.VALET_BATON, Carte.VALET_COUPE)); - Joueur joueurZaku = unJoueurAvec(main(Carte.VALET_PIECE, Carte.CAVALIER_PIECE, Carte.ROI_BATON, Carte.ROI_COUPE)); - - Joueur vainqueur = new Jeu().meilleurParmi(new Opposants(joueurEsku, joueurZaku)); - - assertThat(vainqueur).isEqualTo(joueurZaku); + Joueur joueur1 = unJoueurAvec(main(Carte.VALET_COUPE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.ROI_EPEE)); + Joueur joueur2 = unJoueurAvec(main(Carte.VALET_COUPE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.SEPT_PIECE)); + Joueur joueur3 = unJoueurAvec(main(Carte.VALET_COUPE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.SEPT_EPEE)); + Joueur joueur4 = unJoueurAvec(main(Carte.VALET_COUPE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.SEPT_BATON)); + Equipe equipe1 = new Equipe(joueur1,joueur2); + Equipe equipe2 = new Equipe(joueur3,joueur4); + + Joueur vainqueur = new Jeu().meilleurParmi(new Opposants(equipe1, equipe2)); + assertThat(vainqueur).isEqualTo(joueur1); } @Test void devrait_faire_gagner_le_joueur_ayant_36_par_rapport_a_33() { - Joueur joueurEsku = unJoueurAvec(main(Carte.SEPT_BATON, Carte.SIX_BATON, Carte.VALET_BATON, Carte.VALET_COUPE)); - Joueur joueurZaku = unJoueurAvec(main(Carte.VALET_PIECE, Carte.CAVALIER_PIECE, Carte.ROI_BATON, Carte.TROIS_BATON)); - - Joueur vainqueur = new Jeu().meilleurParmi(new Opposants(joueurEsku, joueurZaku)); - - assertThat(vainqueur).isEqualTo(joueurEsku); + Joueur joueur1 = unJoueurAvec(main(Carte.VALET_COUPE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.SIX_BATON)); + Joueur joueur2 = unJoueurAvec(main(Carte.VALET_COUPE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.TROIS_PIECE)); + Joueur joueur3 = unJoueurAvec(main(Carte.VALET_COUPE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.TROIS_EPEE)); + Joueur joueur4 = unJoueurAvec(main(Carte.VALET_COUPE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.TROIS_BATON)); + Equipe equipe1 = new Equipe(joueur1,joueur2); + Equipe equipe2 = new Equipe(joueur3,joueur4); + + Joueur vainqueur = new Jeu().meilleurParmi(new Opposants(equipe1, equipe2)); + assertThat(vainqueur).isEqualTo(joueur1); } @Test void devrait_faire_gagner_le_joueur_esku_en_cas_d_egalite() { - Joueur joueurEsku = unJoueurAvec(main(Carte.VALET_EPEE, Carte.AS_BATON, Carte.VALET_BATON, Carte.VALET_COUPE)); - Joueur joueurZaku = unJoueurAvec(main(Carte.VALET_PIECE, Carte.CAVALIER_PIECE, Carte.ROI_BATON, Carte.AS_PIECE)); - - Joueur vainqueur = new Jeu().meilleurParmi(new Opposants(joueurEsku, joueurZaku)); - - assertThat(vainqueur).isEqualTo(joueurEsku); + Joueur joueur1 = unJoueurAvec(main(Carte.VALET_COUPE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.TROIS_COUPE)); + Joueur joueur2 = unJoueurAvec(main(Carte.VALET_COUPE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.TROIS_PIECE)); + Joueur joueur3 = unJoueurAvec(main(Carte.VALET_COUPE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.TROIS_EPEE)); + Joueur joueur4 = unJoueurAvec(main(Carte.VALET_COUPE, Carte.ROI_COUPE, Carte.CAVALIER_PIECE, Carte.TROIS_BATON)); + Equipe equipe1 = new Equipe(joueur1,joueur2); + Equipe equipe2 = new Equipe(joueur3,joueur4); + + Joueur vainqueur = new Jeu().meilleurParmi(new Opposants(equipe1, equipe2)); + assertThat(vainqueur).isEqualTo(joueur1); } @Test void devrait_accorder_un_bonus_de_3_pour_31() { - Joueur joueurEsku = unJoueurAvec(main(Carte.VALET_EPEE, Carte.AS_BATON, Carte.VALET_BATON, Carte.VALET_COUPE)); + Joueur joueur1 = unJoueurAvec(main(Carte.VALET_EPEE, Carte.AS_BATON, Carte.VALET_BATON, Carte.VALET_COUPE)); - int pointsBonus = new Jeu().pointsBonus(joueurEsku); + int pointsBonus = new Jeu().pointsBonus(joueur1); assertThat(pointsBonus).isEqualTo(3); } @Test void devrait_accorder_un_bonus_de_2_pour_32() { - Joueur joueurEsku = unJoueurAvec(main(Carte.VALET_EPEE, Carte.DEUX_BATON, Carte.VALET_BATON, Carte.VALET_COUPE)); + Joueur joueur1 = unJoueurAvec(main(Carte.VALET_EPEE, Carte.DEUX_BATON, Carte.VALET_BATON, Carte.VALET_COUPE)); - int pointsBonus = new Jeu().pointsBonus(joueurEsku); + int pointsBonus = new Jeu().pointsBonus(joueur1); assertThat(pointsBonus).isEqualTo(2); } diff --git a/src/test/java/com/montaury/mus/jeu/tour/phases/MusTest.java b/src/test/java/com/montaury/mus/jeu/tour/phases/MusTest.java index 927849b..b2e6b06 100644 --- a/src/test/java/com/montaury/mus/jeu/tour/phases/MusTest.java +++ b/src/test/java/com/montaury/mus/jeu/tour/phases/MusTest.java @@ -2,10 +2,11 @@ import com.montaury.mus.jeu.carte.Carte; import com.montaury.mus.jeu.carte.Defausse; +import com.montaury.mus.jeu.equipe.Equipe; import com.montaury.mus.jeu.joueur.AffichageConsoleEvenementsDeJeu; import com.montaury.mus.jeu.joueur.InterfaceJoueur; import com.montaury.mus.jeu.joueur.Joueur; -import com.montaury.mus.jeu.joueur.Opposants; +import com.montaury.mus.jeu.equipe.Opposants; import java.util.List; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -22,84 +23,134 @@ class MusTest { @BeforeEach void setUp() { defausse = new Defausse(); - mus = new Mus(paquetEntierCroissant(), defausse, new AffichageConsoleEvenementsDeJeu(joueurEsku)); - interfaceJoueurEsku = mock(InterfaceJoueur.class); - interfaceJoueurZaku = mock(InterfaceJoueur.class); - joueurEsku = new Joueur("J1", interfaceJoueurEsku); - joueurZaku = new Joueur("J2", interfaceJoueurZaku); - opposants = new Opposants(joueurEsku, joueurZaku); + mus = new Mus(paquetEntierCroissant(), defausse, new AffichageConsoleEvenementsDeJeu(joueur1)); + interfaceJoueur1 = mock(InterfaceJoueur.class); + interfaceJoueur2 = mock(InterfaceJoueur.class); + interfaceJoueur3 = mock(InterfaceJoueur.class); + interfaceJoueur4 = mock(InterfaceJoueur.class); + joueur1 = new Joueur("J1", interfaceJoueur1); + joueur2 = new Joueur("J2", interfaceJoueur2); + joueur3 = new Joueur("J3", interfaceJoueur3); + joueur4 = new Joueur("J4", interfaceJoueur4); + + equipe1 = new Equipe(joueur1,joueur2); + equipe2 = new Equipe(joueur3,joueur4); + + opposants = new Opposants(equipe1, equipe2); } @Test void devrait_distribuer_quatre_cartes_a_chaque_joueur() { - when(interfaceJoueurEsku.veutAllerMus()).thenReturn(false); + when(interfaceJoueur1.veutAllerMus()).thenReturn(false); mus.jouer(opposants); - assertThat(joueurEsku.main().cartes()).containsExactly(Carte.AS_BATON, Carte.AS_COUPE, Carte.AS_EPEE, Carte.AS_PIECE); - assertThat(joueurZaku.main().cartes()).containsExactly(Carte.DEUX_BATON, Carte.DEUX_COUPE, Carte.DEUX_EPEE, Carte.DEUX_PIECE); + assertThat(joueur1.main().cartes()).containsExactly(Carte.AS_BATON, Carte.AS_COUPE, Carte.AS_EPEE, Carte.AS_PIECE); + assertThat(joueur2.main().cartes()).containsExactly(Carte.TROIS_BATON, Carte.TROIS_COUPE, Carte.TROIS_EPEE, Carte.TROIS_PIECE); + assertThat(joueur3.main().cartes()).containsExactly(Carte.DEUX_BATON, Carte.DEUX_COUPE, Carte.DEUX_EPEE, Carte.DEUX_PIECE); + assertThat(joueur4.main().cartes()).containsExactly(Carte.QUATRE_BATON, Carte.QUATRE_COUPE, Carte.QUATRE_EPEE, Carte.QUATRE_PIECE); } @Test - void devrait_se_terminer_si_le_joueur_esku_veut_sortir() { - when(interfaceJoueurEsku.veutAllerMus()).thenReturn(false); + void devrait_se_terminer_si_le_joueur_1_veut_sortir() { + when(interfaceJoueur1.veutAllerMus()).thenReturn(false); mus.jouer(opposants); - verify(interfaceJoueurZaku, times(0)).veutAllerMus(); + verify(interfaceJoueur3, times(0)).veutAllerMus(); } + /* l equipié du joueur etant aleatire pour le choix de mus pas de test car forcement true si bot plus intelligent change + @Test + void devrait_se_terminer_si_le_joueur_2_veut_sortir() { + when(interfaceJoueur1.veutAllerMus()).thenReturn(true); + when(interfaceJoueur3.veutAllerMus()).thenReturn(true); + when(interfaceJoueur2.veutAllerMus()).thenReturn(false); + + mus.jouer(opposants); + + verify(interfaceJoueur4, times(0)).veutAllerMus(); + }*/ @Test - void devrait_se_terminer_si_le_joueur_zaku_veut_sortir() { - when(interfaceJoueurEsku.veutAllerMus()).thenReturn(true); - when(interfaceJoueurZaku.veutAllerMus()).thenReturn(false); + void devrait_se_terminer_si_le_joueur_3_veut_sortir() { + when(interfaceJoueur1.veutAllerMus()).thenReturn(true); + when(interfaceJoueur3.veutAllerMus()).thenReturn(false); + mus.jouer(opposants); + verify(interfaceJoueur2, times(0)).veutAllerMus(); + } + + @Test + void devrait_se_terminer_si_le_joueur_4_veut_sortir() { + when(interfaceJoueur1.veutAllerMus()).thenReturn(true); + when(interfaceJoueur2.veutAllerMus()).thenReturn(true); + when(interfaceJoueur3.veutAllerMus()).thenReturn(true); + when(interfaceJoueur4.veutAllerMus()).thenReturn(false); mus.jouer(opposants); - verify(interfaceJoueurEsku, times(0)).cartesAJeter(); + verify(interfaceJoueur1, times(0)).cartesAJeter(); } @Test void devrait_demander_les_cartes_a_jeter_aux_joueurs_s_ils_vont_mus() { - when(interfaceJoueurEsku.veutAllerMus()).thenReturn(true, false); - when(interfaceJoueurZaku.veutAllerMus()).thenReturn(true); - + when(interfaceJoueur1.veutAllerMus()).thenReturn(true,false); + when(interfaceJoueur2.veutAllerMus()).thenReturn(true); + when(interfaceJoueur3.veutAllerMus()).thenReturn(true); + when(interfaceJoueur4.veutAllerMus()).thenReturn(true); mus.jouer(opposants); - verify(interfaceJoueurEsku, times(1)).cartesAJeter(); - verify(interfaceJoueurZaku, times(1)).cartesAJeter(); + verify(interfaceJoueur1, times(1)).cartesAJeter(); + verify(interfaceJoueur2, times(1)).cartesAJeter(); + verify(interfaceJoueur3, times(1)).cartesAJeter(); + verify(interfaceJoueur4, times(1)).cartesAJeter(); } @Test void devrait_defausser_les_cartes_a_jeter_si_les_joueurs_vont_mus() { - when(interfaceJoueurEsku.veutAllerMus()).thenReturn(true, false); - when(interfaceJoueurEsku.cartesAJeter()).thenReturn(List.of(Carte.AS_COUPE)); - when(interfaceJoueurZaku.veutAllerMus()).thenReturn(true); - when(interfaceJoueurZaku.cartesAJeter()).thenReturn(List.of(Carte.DEUX_COUPE)); + when(interfaceJoueur1.veutAllerMus()).thenReturn(true, false); + when(interfaceJoueur1.cartesAJeter()).thenReturn(List.of(Carte.AS_COUPE)); + when(interfaceJoueur2.veutAllerMus()).thenReturn(true); + when(interfaceJoueur2.cartesAJeter()).thenReturn(List.of(Carte.DEUX_COUPE)); + when(interfaceJoueur3.veutAllerMus()).thenReturn(true); + when(interfaceJoueur3.cartesAJeter()).thenReturn(List.of(Carte.TROIS_COUPE)); + when(interfaceJoueur4.veutAllerMus()).thenReturn(true); + when(interfaceJoueur4.cartesAJeter()).thenReturn(List.of(Carte.QUATRE_COUPE)); mus.jouer(opposants); - assertThat(defausse.reprendreCartes()).containsExactly(Carte.AS_COUPE, Carte.DEUX_COUPE); + assertThat(defausse.reprendreCartes()).containsExactly(Carte.AS_COUPE, Carte.TROIS_COUPE, Carte.DEUX_COUPE,Carte.QUATRE_COUPE); } @Test void devrait_distribuer_des_cartes_pour_remplacer_les_cartes_jetees_si_les_joueurs_vont_mus() { - when(interfaceJoueurEsku.veutAllerMus()).thenReturn(true, false); - when(interfaceJoueurEsku.cartesAJeter()).thenReturn(List.of(Carte.AS_COUPE)); - when(interfaceJoueurZaku.veutAllerMus()).thenReturn(true); - when(interfaceJoueurZaku.cartesAJeter()).thenReturn(List.of(Carte.DEUX_COUPE)); + when(interfaceJoueur1.veutAllerMus()).thenReturn(true, false); + when(interfaceJoueur1.cartesAJeter()).thenReturn(List.of(Carte.AS_COUPE)); + when(interfaceJoueur2.veutAllerMus()).thenReturn(true); + when(interfaceJoueur2.cartesAJeter()).thenReturn(List.of(Carte.TROIS_COUPE)); + when(interfaceJoueur3.veutAllerMus()).thenReturn(true); + when(interfaceJoueur3.cartesAJeter()).thenReturn(List.of(Carte.DEUX_COUPE)); + when(interfaceJoueur4.veutAllerMus()).thenReturn(true); + when(interfaceJoueur4.cartesAJeter()).thenReturn(List.of(Carte.QUATRE_COUPE)); mus.jouer(opposants); - assertThat(joueurEsku.main().cartes()).containsExactly(Carte.AS_BATON, Carte.AS_EPEE, Carte.AS_PIECE, Carte.TROIS_BATON); - assertThat(joueurZaku.main().cartes()).containsExactly(Carte.DEUX_BATON, Carte.DEUX_EPEE, Carte.DEUX_PIECE, Carte.TROIS_COUPE); + assertThat(joueur1.main().cartes()).containsExactly(Carte.AS_BATON, Carte.AS_EPEE, Carte.AS_PIECE , Carte.CINQ_BATON); + assertThat(joueur2.main().cartes()).containsExactly(Carte.TROIS_BATON, Carte.TROIS_EPEE, Carte.TROIS_PIECE , Carte.CINQ_EPEE); + assertThat(joueur3.main().cartes()).containsExactly( Carte.DEUX_BATON, Carte.DEUX_EPEE, Carte.DEUX_PIECE , Carte.CINQ_COUPE); + assertThat(joueur4.main().cartes()).containsExactly(Carte.QUATRE_BATON, Carte.QUATRE_EPEE, Carte.QUATRE_PIECE , Carte.CINQ_PIECE); } private Mus mus; - private InterfaceJoueur interfaceJoueurEsku; - private InterfaceJoueur interfaceJoueurZaku; - private Joueur joueurEsku; - private Joueur joueurZaku; + private InterfaceJoueur interfaceJoueur1; + private InterfaceJoueur interfaceJoueur2; + private InterfaceJoueur interfaceJoueur3; + private InterfaceJoueur interfaceJoueur4; + private Joueur joueur1; + private Joueur joueur2; + private Joueur joueur3; + private Joueur joueur4; + private Equipe equipe1; + private Equipe equipe2; private Opposants opposants; private Defausse defausse; } \ No newline at end of file diff --git a/src/test/java/com/montaury/mus/jeu/tour/phases/PairesTest.java b/src/test/java/com/montaury/mus/jeu/tour/phases/PairesTest.java index ad55369..89550ad 100644 --- a/src/test/java/com/montaury/mus/jeu/tour/phases/PairesTest.java +++ b/src/test/java/com/montaury/mus/jeu/tour/phases/PairesTest.java @@ -1,8 +1,9 @@ package com.montaury.mus.jeu.tour.phases; import com.montaury.mus.jeu.carte.Carte; +import com.montaury.mus.jeu.equipe.Equipe; +import com.montaury.mus.jeu.equipe.Opposants; import com.montaury.mus.jeu.joueur.Joueur; -import com.montaury.mus.jeu.joueur.Opposants; import org.junit.jupiter.api.Test; import static com.montaury.mus.jeu.joueur.Fixtures.main; @@ -13,8 +14,10 @@ class PairesTest { @Test void ne_doit_pas_se_derouler_si_personne_n_a_de_paires() { Opposants opposants = new Opposants( - unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)), - unJoueurAvec(main(Carte.VALET_PIECE, Carte.SIX_PIECE, Carte.QUATRE_BATON, Carte.AS_PIECE)) + new Equipe( unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)), + unJoueurAvec(main(Carte.VALET_PIECE, Carte.SIX_PIECE, Carte.QUATRE_BATON, Carte.AS_PIECE))), + new Equipe( unJoueurAvec(main(Carte.DEUX_PIECE, Carte.ROI_BATON, Carte.VALET_EPEE, Carte.AS_COUPE)), + unJoueurAvec(main(Carte.DEUX_EPEE, Carte.TROIS_PIECE, Carte.CINQ_BATON, Carte.AS_EPEE))) ); boolean peutSeDerouler = new Paires().peutSeDerouler(opposants); @@ -25,8 +28,10 @@ void ne_doit_pas_se_derouler_si_personne_n_a_de_paires() { @Test void ne_doit_pas_se_derouler_si_un_des_joueurs_n_a_pas_de_paires() { Opposants opposants = new Opposants( - unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)), - unJoueurAvec(main(Carte.VALET_PIECE, Carte.SIX_PIECE, Carte.SIX_EPEE, Carte.AS_PIECE)) + new Equipe( unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)), + unJoueurAvec(main(Carte.VALET_PIECE, Carte.SIX_PIECE, Carte.QUATRE_BATON, Carte.AS_PIECE))), + new Equipe( unJoueurAvec(main(Carte.DEUX_PIECE, Carte.ROI_BATON, Carte.VALET_EPEE, Carte.AS_COUPE)), + unJoueurAvec(main(Carte.DEUX_EPEE, Carte.TROIS_PIECE, Carte.CINQ_BATON, Carte.AS_EPEE))) ); boolean peutSeDerouler = new Paires().peutSeDerouler(opposants); @@ -35,10 +40,12 @@ void ne_doit_pas_se_derouler_si_un_des_joueurs_n_a_pas_de_paires() { } @Test - void devrait_se_derouler_si_les_deux_joueurs_ont_des_paires() { + void devrait_se_derouler_si_un_joueur_de_chaque_equipe_ont_un_ou_des_paires() { Opposants opposants = new Opposants( - unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.QUATRE_COUPE)), - unJoueurAvec(main(Carte.VALET_PIECE, Carte.SIX_PIECE, Carte.SIX_EPEE, Carte.AS_PIECE)) + new Equipe( unJoueurAvec(main(Carte.DEUX_COUPE, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)), + unJoueurAvec(main(Carte.AS_BATON, Carte.SIX_PIECE, Carte.QUATRE_BATON, Carte.AS_PIECE))), + new Equipe( unJoueurAvec(main(Carte.DEUX_PIECE, Carte.DEUX_EPEE, Carte.VALET_EPEE, Carte.AS_COUPE)), + unJoueurAvec(main(Carte.ROI_BATON, Carte.TROIS_PIECE, Carte.CINQ_BATON, Carte.AS_EPEE))) ); boolean peutSeDerouler = new Paires().peutSeDerouler(opposants); @@ -48,15 +55,17 @@ void devrait_se_derouler_si_les_deux_joueurs_ont_des_paires() { @Test void devrait_faire_gagner_le_joueur_ayant_la_meilleure_paire() { - Joueur joueurZaku = unJoueurAvec(main(Carte.VALET_PIECE, Carte.SIX_PIECE, Carte.SIX_EPEE, Carte.AS_PIECE)); + Joueur j2=unJoueurAvec(main(Carte.ROI_EPEE, Carte.SIX_PIECE, Carte.QUATRE_BATON, Carte.ROI_EPEE)); Opposants opposants = new Opposants( - unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.QUATRE_COUPE)), - joueurZaku + new Equipe( unJoueurAvec(main(Carte.DEUX_COUPE, Carte.DEUX_COUPE, Carte.VALET_BATON, Carte.SIX_COUPE)), + j2), + new Equipe( unJoueurAvec(main(Carte.DEUX_PIECE, Carte.DEUX_EPEE, Carte.VALET_EPEE, Carte.AS_COUPE)), + unJoueurAvec(main(Carte.ROI_BATON, Carte.TROIS_PIECE, Carte.TROIS_PIECE, Carte.AS_EPEE))) ); Joueur vainqueur = new Paires().meilleurParmi(opposants); - assertThat(vainqueur).isEqualTo(joueurZaku); + assertThat(vainqueur).isEqualTo(j2); } @Test diff --git a/src/test/java/com/montaury/mus/jeu/tour/phases/PetitTest.java b/src/test/java/com/montaury/mus/jeu/tour/phases/PetitTest.java index 320788f..19a6515 100644 --- a/src/test/java/com/montaury/mus/jeu/tour/phases/PetitTest.java +++ b/src/test/java/com/montaury/mus/jeu/tour/phases/PetitTest.java @@ -1,8 +1,9 @@ package com.montaury.mus.jeu.tour.phases; import com.montaury.mus.jeu.carte.Carte; +import com.montaury.mus.jeu.equipe.Equipe; import com.montaury.mus.jeu.joueur.Joueur; -import com.montaury.mus.jeu.joueur.Opposants; +import com.montaury.mus.jeu.equipe.Opposants; import org.junit.jupiter.api.Test; import static com.montaury.mus.jeu.joueur.Fixtures.main; @@ -11,42 +12,93 @@ class PetitTest { @Test - void devrait_faire_gagner_le_joueur_esku_s_il_a_la_plus_petite_carte() { - Joueur joueurEsku = unJoueurAvec(main(Carte.DEUX_PIECE, Carte.CINQ_PIECE, Carte.SEPT_BATON, Carte.AS_COUPE)); - Joueur joueurZaku = unJoueurAvec(main(Carte.DEUX_BATON, Carte.TROIS_PIECE, Carte.CAVALIER_BATON, Carte.SIX_PIECE)); + void devrait_faire_gagner_le_joueur_1_s_il_a_la_plus_petite_carte() { + Joueur joueur1 = unJoueurAvec(main(Carte.DEUX_PIECE, Carte.CINQ_PIECE, Carte.SEPT_BATON, Carte.AS_COUPE)); + Joueur joueur2 = unJoueurAvec(main(Carte.DEUX_BATON, Carte.DEUX_BATON, Carte.CAVALIER_BATON, Carte.SIX_BATON)); + Joueur joueur3 = unJoueurAvec(main(Carte.TROIS_EPEE, Carte.CINQ_EPEE, Carte.SEPT_EPEE, Carte.VALET_EPEE)); + Joueur joueur4 = unJoueurAvec(main(Carte.DEUX_PIECE, Carte.TROIS_PIECE, Carte.CAVALIER_PIECE, Carte.SIX_PIECE)); - Joueur vainqueur = new Petit().meilleurParmi(new Opposants(joueurEsku, joueurZaku)); + Equipe equipe1 = new Equipe(joueur1,joueur2); + Equipe equipe2 = new Equipe(joueur3,joueur4); - assertThat(vainqueur).isEqualTo(joueurEsku); + Joueur vainqueur = new Petit().meilleurParmi(new Opposants(equipe1, equipe2)); + + assertThat(vainqueur).isEqualTo(joueur1); } @Test - void devrait_faire_gagner_le_joueur_zaku_s_il_a_la_plus_petite_carte() { - Joueur joueurEsku = unJoueurAvec(main(Carte.DEUX_PIECE, Carte.CINQ_PIECE, Carte.SEPT_BATON, Carte.SIX_COUPE)); - Joueur joueurZaku = unJoueurAvec(main(Carte.DEUX_BATON, Carte.TROIS_PIECE, Carte.CAVALIER_BATON, Carte.AS_PIECE)); + void devrait_faire_gagner_le_joueur_2_s_il_a_la_plus_petite_carte() { + Joueur joueur1 = unJoueurAvec(main(Carte.DEUX_BATON, Carte.DEUX_BATON, Carte.CAVALIER_BATON, Carte.SIX_BATON)); + Joueur joueur2 = unJoueurAvec(main(Carte.DEUX_PIECE, Carte.CINQ_PIECE, Carte.SEPT_BATON, Carte.AS_COUPE)); + Joueur joueur3 = unJoueurAvec(main(Carte.TROIS_EPEE, Carte.CINQ_EPEE, Carte.SEPT_EPEE, Carte.VALET_EPEE)); + Joueur joueur4 = unJoueurAvec(main(Carte.DEUX_PIECE, Carte.TROIS_PIECE, Carte.CAVALIER_PIECE, Carte.SIX_PIECE)); + + Equipe equipe1 = new Equipe(joueur1,joueur2); + Equipe equipe2 = new Equipe(joueur3,joueur4); - Joueur vainqueur = new Petit().meilleurParmi(new Opposants(joueurEsku, joueurZaku)); + Joueur vainqueur = new Petit().meilleurParmi(new Opposants(equipe1, equipe2)); - assertThat(vainqueur).isEqualTo(joueurZaku); + assertThat(vainqueur).isEqualTo(joueur2); + } + + @Test + void devrait_faire_gagner_le_joueur_3_s_il_a_la_plus_petite_carte() { + Joueur joueur1 = unJoueurAvec(main(Carte.TROIS_EPEE, Carte.CINQ_EPEE, Carte.SEPT_EPEE, Carte.VALET_EPEE)); + Joueur joueur2 = unJoueurAvec(main(Carte.DEUX_BATON, Carte.DEUX_BATON, Carte.CAVALIER_BATON, Carte.SIX_BATON)); + Joueur joueur3 = unJoueurAvec(main(Carte.DEUX_EPEE, Carte.CINQ_PIECE, Carte.SEPT_BATON, Carte.AS_COUPE)); + Joueur joueur4 = unJoueurAvec(main(Carte.DEUX_PIECE, Carte.TROIS_PIECE, Carte.CAVALIER_PIECE, Carte.SIX_PIECE)); + + Equipe equipe1 = new Equipe(joueur1,joueur2); + Equipe equipe2 = new Equipe(joueur3,joueur4); + + Joueur vainqueur = new Petit().meilleurParmi(new Opposants(equipe1, equipe2)); + + assertThat(vainqueur).isEqualTo(joueur3); + } + + @Test + void devrait_faire_gagner_le_joueur_4_s_il_a_la_plus_petite_carte() { + Joueur joueur1 = unJoueurAvec(main(Carte.DEUX_PIECE, Carte.CINQ_PIECE, Carte.SEPT_BATON, Carte.ROI_PIECE)); + Joueur joueur2 = unJoueurAvec(main(Carte.DEUX_BATON, Carte.ROI_BATON, Carte.CAVALIER_BATON, Carte.SIX_BATON)); + Joueur joueur3 = unJoueurAvec(main(Carte.DEUX_EPEE, Carte.TROIS_PIECE, Carte.CAVALIER_PIECE, Carte.SIX_PIECE)); + Joueur joueur4 = unJoueurAvec(main(Carte.DEUX_COUPE, Carte.CINQ_EPEE, Carte.SEPT_PIECE, Carte.AS_COUPE)); + + Equipe equipe1 = new Equipe(joueur1,joueur2); + Equipe equipe2 = new Equipe(joueur3,joueur4); + + Joueur vainqueur = new Petit().meilleurParmi(new Opposants(equipe1, equipe2)); + + assertThat(vainqueur).isEqualTo(joueur4); } @Test void devrait_faire_gagner_le_joueur_qui_a_la_seconde_plus_petite_carte_si_la_premiere_est_egale() { - Joueur joueurEsku = unJoueurAvec(main(Carte.AS_BATON, Carte.CINQ_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)); - Joueur joueurZaku = unJoueurAvec(main(Carte.DEUX_BATON, Carte.VALET_PIECE, Carte.QUATRE_BATON, Carte.AS_PIECE)); - Joueur vainqueur = new Petit().meilleurParmi(new Opposants(joueurEsku, joueurZaku)); + Joueur joueur1 = unJoueurAvec(main(Carte.AS_PIECE, Carte.CINQ_PIECE, Carte.SEPT_BATON, Carte.TROIS_BATON)); + Joueur joueur2 = unJoueurAvec(main(Carte.AS_BATON, Carte.CAVALIER_EPEE, Carte.CAVALIER_BATON, Carte.SIX_BATON)); + Joueur joueur3 = unJoueurAvec(main(Carte.AS_PIECE, Carte.TROIS_PIECE, Carte.CAVALIER_PIECE, Carte.SIX_PIECE)); + Joueur joueur4 = unJoueurAvec(main(Carte.AS_PIECE, Carte.CINQ_PIECE, Carte.SEPT_BATON, Carte.DEUX_COUPE)); + + Equipe equipe1 = new Equipe(joueur1,joueur2); + Equipe equipe2 = new Equipe(joueur3,joueur4); - assertThat(vainqueur).isEqualTo(joueurZaku); + Joueur vainqueur = new Petit().meilleurParmi(new Opposants(equipe1, equipe2)); + + assertThat(vainqueur).isEqualTo(joueur4); } @Test void devrait_faire_gagner_le_joueur_esku_si_les_deux_mains_sont_egales() { - Joueur joueurEsku = unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)); - Joueur joueurZaku = unJoueurAvec(main(Carte.VALET_PIECE, Carte.SIX_PIECE, Carte.QUATRE_BATON, Carte.AS_PIECE)); + Joueur joueur1 = unJoueurAvec(main(Carte.AS_PIECE, Carte.CINQ_PIECE, Carte.CAVALIER_EPEE, Carte.SIX_COUPE)); + Joueur joueur2 = unJoueurAvec(main(Carte.ROI_EPEE, Carte.ROI_EPEE, Carte.ROI_EPEE, Carte.ROI_EPEE)); + Joueur joueur3 = unJoueurAvec(main(Carte.ROI_EPEE, Carte.ROI_EPEE, Carte.ROI_EPEE, Carte.ROI_EPEE)); + Joueur joueur4 = unJoueurAvec(main(Carte.AS_PIECE, Carte.CINQ_COUPE, Carte.CAVALIER_COUPE, Carte.SIX_EPEE)); + + Equipe equipe1 = new Equipe(joueur1,joueur2); + Equipe equipe2 = new Equipe(joueur3,joueur4); - Joueur vainqueur = new Petit().meilleurParmi(new Opposants(joueurEsku, joueurZaku)); + Joueur vainqueur = new Petit().meilleurParmi(new Opposants(equipe1, equipe2)); - assertThat(vainqueur).isEqualTo(joueurEsku); + assertThat(vainqueur).isEqualTo(joueur1); } } \ No newline at end of file