From 6eb19981d788dd51816760623f223a63ab739ddf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Coussy?= Date: Thu, 25 Feb 2021 16:55:30 +0100 Subject: [PATCH 01/12] debut d'iteration2: creation equipe adaptation de certaines classe --- src/main/java/com/montaury/mus/Mus.java | 6 +- .../java/com/montaury/mus/jeu/Partie.java | 6 +- .../com/montaury/mus/jeu/equipe/Equipe.java | 28 +++++++++ .../montaury/mus/jeu/equipe/Opposants.java | 59 +++++++++++++++++++ .../montaury/mus/jeu/joueur/Opposants.java | 58 ------------------ 5 files changed, 94 insertions(+), 63 deletions(-) create mode 100644 src/main/java/com/montaury/mus/jeu/equipe/Equipe.java create mode 100644 src/main/java/com/montaury/mus/jeu/equipe/Opposants.java delete mode 100644 src/main/java/com/montaury/mus/jeu/joueur/Opposants.java diff --git a/src/main/java/com/montaury/mus/Mus.java b/src/main/java/com/montaury/mus/Mus.java index 56300eb..bfcaf3f 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() ), + new Equipe(Joueur.ordinateur(),Joueur.ordinateur()))); System.out.println("Le vainqueur de la partie est " + resultat.vainqueur().nom()); } diff --git a/src/main/java/com/montaury/mus/jeu/Partie.java b/src/main/java/com/montaury/mus/jeu/Partie.java index 474f68f..8007e28 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,8 @@ 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.equipeEsku(), 0); + this.manchesGagneesParJoueur.put(opposants.equipeZaku(), 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..750b52f --- /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 + Joueur joueur1; + 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..bccf700 --- /dev/null +++ b/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java @@ -0,0 +1,59 @@ +package com.montaury.mus.jeu.equipe; + +import java.util.Iterator; +import java.util.List; + +public class Opposants { + private Equipe equipeEsku; + private Equipe equipeZaku; + + + public Opposants(Equipe equipeEsku, Equipe equipeZaku) { + this.equipeEsku = equipeEsku; + this.equipeZaku = equipeZaku; + } + // permet de changer celui qui distribue et celui qui parle en premier + public void tourner() { + Equipe equipetamp = equipeZaku; + equipeZaku = equipeEsku; + equipeEsku = equipetamp; + } + + public Equipe equipeEsku() { + return equipeEsku; + } + + public Equipe equipeZaku() { + return equipeZaku; + } + + public Iterator itererDansLOrdre() { //permet de passer d'un equipe a l autre pour avoir ses données + return new IteratorInfini(this); + } + + public List dansLOrdre() { + return List.of(equipeEsku, equipeZaku); + } + + private static class IteratorInfini implements Iterator { + private final Opposants opposants; + private Equipe suivant; + + public IteratorInfini(Opposants opposants) { + this.opposants = opposants; + suivant = opposants.equipeEsku; + } + + @Override + public boolean hasNext() { + return true; + } + + @Override + public Equipe next() { + Equipe next = suivant; + suivant = suivant == opposants.equipeEsku ? opposants.equipeZaku : opposants.equipeEsku; + return next; + } + } +} 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; - } - } -} From def9b2b855c78d5965f05fd9dc83586cb64284ca Mon Sep 17 00:00:00 2001 From: toto Date: Thu, 4 Mar 2021 16:06:26 +0100 Subject: [PATCH 02/12] -Premiere implementation Equipe --- .../java/com/montaury/mus/jeu/Manche.java | 2 +- .../java/com/montaury/mus/jeu/Partie.java | 4 +- .../com/montaury/mus/jeu/equipe/Equipe.java | 4 +- .../montaury/mus/jeu/equipe/Opposants.java | 46 ++++++++++--------- .../AffichageConsoleEvenementsDeJeu.java | 2 + .../jeu/joueur/AffichageEvenementsDeJeu.java | 1 + .../java/com/montaury/mus/jeu/tour/Tour.java | 2 +- .../montaury/mus/jeu/tour/phases/FauxJeu.java | 2 +- .../montaury/mus/jeu/tour/phases/Grand.java | 2 +- .../com/montaury/mus/jeu/tour/phases/Jeu.java | 2 +- .../com/montaury/mus/jeu/tour/phases/Mus.java | 2 +- .../montaury/mus/jeu/tour/phases/Paires.java | 2 +- .../montaury/mus/jeu/tour/phases/Petit.java | 2 +- .../montaury/mus/jeu/tour/phases/Phase.java | 3 +- .../jeu/tour/phases/dialogue/Dialogue.java | 3 +- 15 files changed, 44 insertions(+), 35 deletions(-) diff --git a/src/main/java/com/montaury/mus/jeu/Manche.java b/src/main/java/com/montaury/mus/jeu/Manche.java index f8f109a..2b035d2 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; diff --git a/src/main/java/com/montaury/mus/jeu/Partie.java b/src/main/java/com/montaury/mus/jeu/Partie.java index 8007e28..2911229 100644 --- a/src/main/java/com/montaury/mus/jeu/Partie.java +++ b/src/main/java/com/montaury/mus/jeu/Partie.java @@ -35,8 +35,8 @@ public static class Score { private final Map manchesGagneesParJoueur = new HashMap<>(); public Score(Opposants opposants) { - this.manchesGagneesParJoueur.put(opposants.equipeEsku(), 0); - this.manchesGagneesParJoueur.put(opposants.equipeZaku(), 0); + this.manchesGagneesParJoueur.put(opposants.joueurEsku(), 0); + this.manchesGagneesParJoueur.put(opposants.joueurZaku(), 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 index 750b52f..4fa8212 100644 --- a/src/main/java/com/montaury/mus/jeu/equipe/Equipe.java +++ b/src/main/java/com/montaury/mus/jeu/equipe/Equipe.java @@ -5,8 +5,8 @@ public class Equipe { //attribut - Joueur joueur1; - Joueur joueur2; + public Joueur joueur1; + public Joueur joueur2; //constructeur public Equipe(Joueur j1, Joueur j2) diff --git a/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java b/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java index bccf700..ff9de7a 100644 --- a/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java +++ b/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java @@ -1,47 +1,51 @@ package com.montaury.mus.jeu.equipe; +import com.montaury.mus.jeu.equipe.Equipe; +import com.montaury.mus.jeu.joueur.Joueur; + import java.util.Iterator; + import java.util.List; public class Opposants { - private Equipe equipeEsku; - private Equipe equipeZaku; + private Joueur joueurEsku; + private Joueur joueurZaku; - public Opposants(Equipe equipeEsku, Equipe equipeZaku) { - this.equipeEsku = equipeEsku; - this.equipeZaku = equipeZaku; + public Opposants(Equipe joueurEsku, Equipe joueurZaku) { + this.joueurEsku = joueurEsku.joueur1; + this.joueurZaku = joueurZaku.joueur2; } // permet de changer celui qui distribue et celui qui parle en premier public void tourner() { - Equipe equipetamp = equipeZaku; - equipeZaku = equipeEsku; - equipeEsku = equipetamp; + Joueur Joueurtamp = joueurZaku; + joueurZaku = joueurEsku; + joueurEsku = Joueurtamp; } - public Equipe equipeEsku() { - return equipeEsku; + public Joueur joueurEsku() { + return joueurEsku; } - public Equipe equipeZaku() { - return equipeZaku; + public Joueur joueurZaku() { + return joueurZaku; } - public Iterator itererDansLOrdre() { //permet de passer d'un equipe a l autre pour avoir ses données + 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 List.of(equipeEsku, equipeZaku); + public List dansLOrdre() { + return List.of(joueurEsku, joueurZaku); } - private static class IteratorInfini implements Iterator { + private static class IteratorInfini implements Iterator { private final Opposants opposants; - private Equipe suivant; + private Joueur suivant; public IteratorInfini(Opposants opposants) { this.opposants = opposants; - suivant = opposants.equipeEsku; + suivant = opposants.joueurEsku; } @Override @@ -50,9 +54,9 @@ public boolean hasNext() { } @Override - public Equipe next() { - Equipe next = suivant; - suivant = suivant == opposants.equipeEsku ? opposants.equipeZaku : opposants.equipeEsku; + 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/joueur/AffichageConsoleEvenementsDeJeu.java b/src/main/java/com/montaury/mus/jeu/joueur/AffichageConsoleEvenementsDeJeu.java index a49e334..f0bc088 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 { 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/tour/Tour.java b/src/main/java/com/montaury/mus/jeu/tour/Tour.java index 67bba0d..0d06469 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; 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..9858e4c 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; 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..4610205 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,7 +4,7 @@ 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; 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..99e7b50 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 { 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..af5fb8a 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,7 +5,7 @@ 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; 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..6f64012 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() { 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..b72fd97 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,7 +4,7 @@ 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; 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..694e850 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,10 @@ 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.equipe.Opposants; import com.montaury.mus.jeu.tour.phases.dialogue.Dialogue; import com.montaury.mus.jeu.tour.phases.dialogue.DialogueTermine; import java.util.List; 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; From 9da3815d505a09259456cc9b2bed334cbfb41a0a Mon Sep 17 00:00:00 2001 From: Arthur Gianini Date: Thu, 4 Mar 2021 16:54:44 +0100 Subject: [PATCH 03/12] implementer 1 joueur et 3 ordinateurs qui jouent, 1V1V1V1 --- .../com/montaury/mus/jeu/equipe/Equipe.java | 2 +- .../montaury/mus/jeu/equipe/Opposants.java | 45 +++++++++++++------ 2 files changed, 33 insertions(+), 14 deletions(-) diff --git a/src/main/java/com/montaury/mus/jeu/equipe/Equipe.java b/src/main/java/com/montaury/mus/jeu/equipe/Equipe.java index 4fa8212..27b3405 100644 --- a/src/main/java/com/montaury/mus/jeu/equipe/Equipe.java +++ b/src/main/java/com/montaury/mus/jeu/equipe/Equipe.java @@ -6,7 +6,7 @@ public class Equipe { //attribut public Joueur joueur1; - public Joueur joueur2; + public Joueur joueur2; //constructeur public Equipe(Joueur j1, Joueur j2) diff --git a/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java b/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java index ff9de7a..3ab823f 100644 --- a/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java +++ b/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java @@ -1,6 +1,5 @@ package com.montaury.mus.jeu.equipe; -import com.montaury.mus.jeu.equipe.Equipe; import com.montaury.mus.jeu.joueur.Joueur; import java.util.Iterator; @@ -8,27 +7,27 @@ import java.util.List; public class Opposants { - private Joueur joueurEsku; - private Joueur joueurZaku; + private Equipe equipe1; + private Equipe equipe2; public Opposants(Equipe joueurEsku, Equipe joueurZaku) { - this.joueurEsku = joueurEsku.joueur1; - this.joueurZaku = joueurZaku.joueur2; + this.equipe1 = joueurEsku; + this.equipe2 = joueurZaku; } // permet de changer celui qui distribue et celui qui parle en premier public void tourner() { - Joueur Joueurtamp = joueurZaku; - joueurZaku = joueurEsku; - joueurEsku = Joueurtamp; + Joueur Joueurtamp = equipe2.joueur1; + equipe2.joueur1 = equipe1.joueur1; + equipe1.joueur1 = Joueurtamp; } public Joueur joueurEsku() { - return joueurEsku; + return equipe1.joueur1; } public Joueur joueurZaku() { - return joueurZaku; + return equipe2.joueur1; } public Iterator itererDansLOrdre() { //permet de passer d'un Joueur a l autre pour avoir ses données @@ -36,7 +35,7 @@ public Iterator itererDansLOrdre() { //permet de passer d'un Joueur a l } public List dansLOrdre() { - return List.of(joueurEsku, joueurZaku); + return List.of(equipe1.joueur1, equipe2.joueur1, equipe1.joueur2, equipe2.joueur2); } private static class IteratorInfini implements Iterator { @@ -45,7 +44,7 @@ private static class IteratorInfini implements Iterator { public IteratorInfini(Opposants opposants) { this.opposants = opposants; - suivant = opposants.joueurEsku; + suivant = opposants.equipe1.joueur1; } @Override @@ -56,7 +55,27 @@ public boolean hasNext() { @Override public Joueur next() { Joueur next = suivant; - suivant = suivant == opposants.joueurEsku ? opposants.joueurZaku : opposants.joueurEsku; + 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; } } From 2ac7f52d65e9e561988b9a9ffea2c3f11d154b5f Mon Sep 17 00:00:00 2001 From: toto Date: Thu, 11 Mar 2021 15:54:01 +0100 Subject: [PATCH 04/12] ajouter de la rotation par equipe et personalisation des noms des ordinateurs --- src/main/java/com/montaury/mus/Mus.java | 4 ++-- .../java/com/montaury/mus/jeu/equipe/Opposants.java | 12 ++++++------ .../java/com/montaury/mus/jeu/joueur/Joueur.java | 4 ++-- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/src/main/java/com/montaury/mus/Mus.java b/src/main/java/com/montaury/mus/Mus.java index bfcaf3f..0e6b597 100644 --- a/src/main/java/com/montaury/mus/Mus.java +++ b/src/main/java/com/montaury/mus/Mus.java @@ -14,8 +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( new Equipe( humain, Joueur.ordinateur() ), - new Equipe(Joueur.ordinateur(),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/equipe/Opposants.java b/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java index 3ab823f..f7e25e9 100644 --- a/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java +++ b/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java @@ -11,15 +11,15 @@ public class Opposants { private Equipe equipe2; - public Opposants(Equipe joueurEsku, Equipe joueurZaku) { - this.equipe1 = joueurEsku; - this.equipe2 = joueurZaku; + public Opposants(Equipe equipe1, Equipe equipe2) { + this.equipe1 = equipe1; + this.equipe2 = equipe2; } // permet de changer celui qui distribue et celui qui parle en premier public void tourner() { - Joueur Joueurtamp = equipe2.joueur1; - equipe2.joueur1 = equipe1.joueur1; - equipe1.joueur1 = Joueurtamp; + Equipe equipeTemp = equipe2; + equipe2 = equipe1; + equipe1 = equipeTemp; } public Joueur joueurEsku() { 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; From 206eadf7add1aa9a53e40da24a8dc431ead695d5 Mon Sep 17 00:00:00 2001 From: toto Date: Thu, 18 Mar 2021 17:00:08 +0100 Subject: [PATCH 05/12] =?UTF-8?q?-mus=20implement=C3=A9=20-debut=20adaptat?= =?UTF-8?q?ion=202v2=20phase=20grand?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../montaury/mus/jeu/equipe/Opposants.java | 9 +++- .../montaury/mus/jeu/tour/phases/Grand.java | 47 +++++++++++++++---- .../com/montaury/mus/jeu/tour/phases/Mus.java | 8 ++++ .../java/com/montaury/mus/jeu/PartieTest.java | 2 +- 4 files changed, 55 insertions(+), 11 deletions(-) diff --git a/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java b/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java index f7e25e9..c112e5f 100644 --- a/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java +++ b/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java @@ -25,10 +25,15 @@ public void tourner() { public Joueur joueurEsku() { return equipe1.joueur1; } - - public Joueur joueurZaku() { + public Joueur joueur2equipe1() { + return equipe1.joueur2; + } + public Joueur joueur1equipe2() { return equipe2.joueur1; } + public Joueur joueurZaku() { + return equipe2.joueur2; + } public Iterator itererDansLOrdre() { //permet de passer d'un Joueur a l autre pour avoir ses données return new IteratorInfini(this); 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 4610205..3686eef 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 @@ -7,8 +7,7 @@ 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() { @@ -18,19 +17,51 @@ public Grand() { @Override protected Joueur meilleurParmi(Opposants opposants) { Joueur joueurEsku = opposants.joueurEsku(); + Joueur joueur2 = opposants.joueur2equipe1(); + Joueur joueur3 = opposants.joueur1equipe2(); Joueur joueurZaku = opposants.joueurZaku(); + Joueur joueurEquipe1Choisi = null; + Joueur joueurEquipe2Choisi = null; + Joueur joueurFinal=null; + + 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 compare = cartesJoueurEsku.get(i).comparerAvec(cartesJoueurZaku.get(i)); - if (compare == PLUS_GRANDE) { - return joueurEsku; + ValeurCarte.Comparaison compareEquipe1 = cartesJoueurEsku.get(i).comparerAvec(cartesjoueur3.get(i)); + if (compareEquipe1 == PLUS_GRANDE || compareEquipe1 == MEME_RANG) { + cartesjoueurPlusGrandEquipe1 = cartesJoueurEsku; + joueurEquipe1Choisi = joueurEsku; + } else if (compareEquipe1 == PLUS_PETITE) { + cartesjoueurPlusGrandEquipe1 = cartesjoueur3; + joueurEquipe1Choisi = joueur3; } - if (compare == PLUS_PETITE) { - return joueurZaku; + + ValeurCarte.Comparaison compareEquipe2 = cartesjoueur2.get(i).comparerAvec(cartesJoueurZaku.get(i)); + if (compareEquipe2 == PLUS_GRANDE || compareEquipe2 == MEME_RANG) { + cartesjoueurPlusGrandEquipe2 = cartesjoueur2; + joueurEquipe2Choisi = joueur2; + } else if (compareEquipe2 == PLUS_PETITE) { + cartesjoueurPlusGrandEquipe2 = cartesJoueurZaku; + joueurEquipe2Choisi = joueurZaku; } + + ValeurCarte.Comparaison compareEntreEquipe = cartesjoueurPlusGrandEquipe1.get(i).comparerAvec(cartesjoueurPlusGrandEquipe2.get(i)); + if (compareEntreEquipe == PLUS_GRANDE || compareEntreEquipe == MEME_RANG) { + joueurFinal= joueurEquipe1Choisi; + } else if (compareEntreEquipe == PLUS_PETITE) { + joueurFinal= joueurEquipe2Choisi; + + } + + } - return joueurEsku; + return joueurFinal; } } 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 af5fb8a..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 @@ -9,6 +9,8 @@ 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/test/java/com/montaury/mus/jeu/PartieTest.java b/src/test/java/com/montaury/mus/jeu/PartieTest.java index a296e0e..317a58e 100644 --- a/src/test/java/com/montaury/mus/jeu/PartieTest.java +++ b/src/test/java/com/montaury/mus/jeu/PartieTest.java @@ -3,7 +3,7 @@ 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; From 4aa797a33e17b96131c7b8ef6183e7eb869eed6e Mon Sep 17 00:00:00 2001 From: toto Date: Mon, 22 Mar 2021 15:51:54 +0100 Subject: [PATCH 06/12] -adaptiation 2v2 phase Grand -adaptation 2v2 phase Petit --- .../montaury/mus/jeu/tour/phases/Grand.java | 23 +++++--- .../montaury/mus/jeu/tour/phases/Petit.java | 58 ++++++++++++++++--- 2 files changed, 65 insertions(+), 16 deletions(-) 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 3686eef..87791c7 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 @@ -17,8 +17,8 @@ public Grand() { @Override protected Joueur meilleurParmi(Opposants opposants) { Joueur joueurEsku = opposants.joueurEsku(); - Joueur joueur2 = opposants.joueur2equipe1(); - Joueur joueur3 = opposants.joueur1equipe2(); + Joueur joueur3 = opposants.joueur2equipe1(); + Joueur joueur2 = opposants.joueur1equipe2(); Joueur joueurZaku = opposants.joueurZaku(); Joueur joueurEquipe1Choisi = null; Joueur joueurEquipe2Choisi = null; @@ -35,32 +35,39 @@ protected Joueur meilleurParmi(Opposants opposants) { for (int i = 0; i < Main.TAILLE; i++) { ValeurCarte.Comparaison compareEquipe1 = cartesJoueurEsku.get(i).comparerAvec(cartesjoueur3.get(i)); - if (compareEquipe1 == PLUS_GRANDE || compareEquipe1 == MEME_RANG) { + 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 compareEquipe2 = cartesjoueur2.get(i).comparerAvec(cartesJoueurZaku.get(i)); - if (compareEquipe2 == PLUS_GRANDE || compareEquipe2 == MEME_RANG) { + if (compareEquipe2 == PLUS_GRANDE) { cartesjoueurPlusGrandEquipe2 = cartesjoueur2; joueurEquipe2Choisi = joueur2; + break; } else if (compareEquipe2 == PLUS_PETITE) { cartesjoueurPlusGrandEquipe2 = cartesJoueurZaku; joueurEquipe2Choisi = joueurZaku; + break; } - + } + for (int i = 0; i < Main.TAILLE; i++) { ValeurCarte.Comparaison compareEntreEquipe = cartesjoueurPlusGrandEquipe1.get(i).comparerAvec(cartesjoueurPlusGrandEquipe2.get(i)); - if (compareEntreEquipe == PLUS_GRANDE || compareEntreEquipe == MEME_RANG) { + if (compareEntreEquipe == PLUS_GRANDE ) { joueurFinal= joueurEquipe1Choisi; + break; } else if (compareEntreEquipe == PLUS_PETITE) { joueurFinal= joueurEquipe2Choisi; + break; } - - } return joueurFinal; } 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 b72fd97..19cb951 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 @@ -7,8 +7,7 @@ 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() { @@ -18,19 +17,62 @@ public Petit() { @Override protected Joueur meilleurParmi(Opposants opposants) { Joueur joueurEsku = opposants.joueurEsku(); + Joueur joueur3 = opposants.joueur2equipe1(); + Joueur joueur2 = opposants.joueur1equipe2(); Joueur joueurZaku = opposants.joueurZaku(); + Joueur joueurEquipe1Choisi = null; + Joueur joueurEquipe2Choisi = null; + Joueur joueurFinal=null; + 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 compare = cartesJoueurEsku.get(i).comparerAvec(cartesJoueurZaku.get(i)); - if (compare == PLUS_PETITE) { - return joueurEsku; + ValeurCarte.Comparaison compareEquipe1 = cartesJoueurEsku.get(i).comparerAvec(cartesjoueur3.get(i)); + if (compareEquipe1 == PLUS_PETITE) { + cartesjoueurPlusGrandEquipe1 = cartesJoueurEsku; + joueurEquipe1Choisi = joueurEsku; + break; } - if (compare == PLUS_GRANDE) { - return joueurZaku; + if (compareEquipe1 == PLUS_GRANDE) { + cartesjoueurPlusGrandEquipe1 = cartesjoueur3; + joueurEquipe1Choisi = joueur3; + break; + } + } + for (int i = Main.TAILLE - 1; i >= 0; i--) { + 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; + } + } + 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; + + + + + } } From 3928cf3738fc444937c48b1ad56faf3be67629cf Mon Sep 17 00:00:00 2001 From: toto Date: Wed, 24 Mar 2021 18:07:34 +0100 Subject: [PATCH 07/12] -adaptiation 2v2 phase Grand -adaptation 2v2 phase Petit --- .../java/com/montaury/mus/jeu/MancheTest.java | 4 ++- .../com/montaury/mus/jeu/tour/TourTest.java | 26 ++++++++++++++++--- 2 files changed, 25 insertions(+), 5 deletions(-) diff --git a/src/test/java/com/montaury/mus/jeu/MancheTest.java b/src/test/java/com/montaury/mus/jeu/MancheTest.java index f87c58d..78625fb 100644 --- a/src/test/java/com/montaury/mus/jeu/MancheTest.java +++ b/src/test/java/com/montaury/mus/jeu/MancheTest.java @@ -3,7 +3,7 @@ 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,6 +24,8 @@ class MancheTest { @BeforeEach void setUp() { + interfaceJoueurEsku = mock(InterfaceJoueur.class); + interfaceJoueurEsku = mock(InterfaceJoueur.class); interfaceJoueurEsku = mock(InterfaceJoueur.class); interfaceJoueurZaku = mock(InterfaceJoueur.class); joueurEsku = new Joueur("J1", interfaceJoueurEsku); 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..d677621 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,10 +30,16 @@ 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("J3", interfaceJoueurZaku); + joueurEnemie = new Joueur("J2", 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()); @@ -42,19 +49,24 @@ void setUp() { void devrait_donner_tous_les_points_au_joueur_esku_si_le_joueur_zaku_fait_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(); @@ -114,8 +126,14 @@ void devrait_privilegier_le_joueur_esku_si_les_mains_sont_identiques() { 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; From 5182744f488c4fe12dcca3e2ff5ab0f075730818 Mon Sep 17 00:00:00 2001 From: toto Date: Wed, 24 Mar 2021 19:31:00 +0100 Subject: [PATCH 08/12] -adaptiation 2v2 phase Paire -adaptation 2v2 phase FauxJeu -ajout au score de 4 joueurs --- .../java/com/montaury/mus/jeu/Manche.java | 4 ++++ .../java/com/montaury/mus/jeu/Partie.java | 2 ++ .../montaury/mus/jeu/tour/phases/FauxJeu.java | 20 +++++++++++++++- .../montaury/mus/jeu/tour/phases/Paires.java | 23 ++++++++++++++++++- 4 files changed, 47 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/montaury/mus/jeu/Manche.java b/src/main/java/com/montaury/mus/jeu/Manche.java index 2b035d2..199eb7d 100644 --- a/src/main/java/com/montaury/mus/jeu/Manche.java +++ b/src/main/java/com/montaury/mus/jeu/Manche.java @@ -33,7 +33,11 @@ public static class Score { public Score(Opposants opposants) { scoreParJoueur.put(opposants.joueurEsku(), 0); + scoreParJoueur.put(opposants.joueur1equipe2(), 0); + scoreParJoueur.put(opposants.joueur2equipe1(), 0); scoreParJoueur.put(opposants.joueurZaku(), 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 2911229..dde1d50 100644 --- a/src/main/java/com/montaury/mus/jeu/Partie.java +++ b/src/main/java/com/montaury/mus/jeu/Partie.java @@ -36,6 +36,8 @@ public static class Score { public Score(Opposants opposants) { this.manchesGagneesParJoueur.put(opposants.joueurEsku(), 0); + this.manchesGagneesParJoueur.put(opposants.joueur1equipe2(), 0); + this.manchesGagneesParJoueur.put(opposants.joueur2equipe1(), 0); this.manchesGagneesParJoueur.put(opposants.joueurZaku(), 0); } 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 9858e4c..cccecc8 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 @@ -18,8 +18,26 @@ protected boolean peutParticiper(Joueur joueur) { @Override protected Joueur meilleurParmi(Opposants opposants) { int pointsJoueurEsku = opposants.joueurEsku().main().pointsPourJeu(); + int pointsJoueurAllie = opposants.joueur1equipe2().main().pointsPourJeu(); + int pointsJoueurEnemie = opposants.joueur2equipe1().main().pointsPourJeu(); int pointsJoueurZaku = opposants.joueurZaku().main().pointsPourJeu(); - return pointsJoueurEsku >= pointsJoueurZaku ? opposants.joueurEsku() : opposants.joueurZaku(); + + int pointsMeilleurJoueurEquipe1 = opposants.joueurEsku().main().pointsPourJeu(); + Joueur meilleurJoueurEquipe1 = opposants.joueurEsku(); + int pointsMeilleurJoueurEquipe2 = opposants.joueurZaku().main().pointsPourJeu(); + Joueur meilleurJoueurEquipe2 = opposants.joueurEsku(); + + if (pointsJoueurAllie >= pointsJoueurEsku){ + pointsMeilleurJoueurEquipe1=pointsJoueurAllie; + meilleurJoueurEquipe1 = opposants.joueur2equipe1(); + } + if (pointsJoueurEnemie >= pointsJoueurZaku){ + pointsMeilleurJoueurEquipe2=pointsJoueurEnemie; + meilleurJoueurEquipe2 = opposants.joueur1equipe2(); + } + + + return pointsMeilleurJoueurEquipe1 >= pointsMeilleurJoueurEquipe2 ? meilleurJoueurEquipe1 : meilleurJoueurEquipe2; } @Override 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 6f64012..3572bbb 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 @@ -16,8 +16,29 @@ 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 pairesJoueurAllie = opposants.joueur2equipe1().main().getPaires(); + com.montaury.mus.jeu.carte.paires.Paires pairesJoueurEnemie = opposants.joueur1equipe2().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 pairesMeilleurEquipe1 = opposants.joueurEsku().main().getPaires(); + com.montaury.mus.jeu.carte.paires.Paires pairesMeilleurEquipe2 = opposants.joueurZaku().main().getPaires(); + Joueur meilleurJoueurEquipe1 =opposants.joueurEsku(); + Joueur meilleurJoueurEquipe2=opposants.joueurZaku(); + + if (pairesJoueurEsku.estMeilleureOuEgaleA(pairesJoueurAllie)){ + pairesMeilleurEquipe1=pairesJoueurEsku; + }else { + pairesMeilleurEquipe1=pairesJoueurAllie; + meilleurJoueurEquipe1=opposants.joueur2equipe1(); + } + + if (pairesJoueurZaku.estMeilleureOuEgaleA(pairesJoueurEnemie)){ + pairesMeilleurEquipe2=pairesJoueurZaku; + }else { + pairesMeilleurEquipe2=pairesJoueurEnemie; + meilleurJoueurEquipe2=opposants.joueur1equipe2(); + } + return pairesMeilleurEquipe1.estMeilleureOuEgaleA(pairesMeilleurEquipe2) ? meilleurJoueurEquipe1 : meilleurJoueurEquipe2; } @Override From aafdd250812546deeabdb5387664e11e08611bd4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Coussy?= Date: Thu, 25 Mar 2021 01:58:21 +0100 Subject: [PATCH 09/12] tous les tests sont sans erreurs et doivent marcher si le code serait fonctionnel --- .../java/com/montaury/mus/jeu/MancheTest.java | 58 +++++--- .../java/com/montaury/mus/jeu/PartieTest.java | 37 ++++-- .../com/montaury/mus/jeu/tour/TourTest.java | 38 +++++- .../mus/jeu/tour/phases/FauxJeuTest.java | 35 +++-- .../mus/jeu/tour/phases/GrandTest.java | 78 ++++++++--- .../montaury/mus/jeu/tour/phases/JeuTest.java | 91 ++++++++----- .../montaury/mus/jeu/tour/phases/MusTest.java | 125 ++++++++++++------ .../mus/jeu/tour/phases/PairesTest.java | 33 +++-- .../mus/jeu/tour/phases/PetitTest.java | 90 ++++++++++--- 9 files changed, 414 insertions(+), 171 deletions(-) diff --git a/src/test/java/com/montaury/mus/jeu/MancheTest.java b/src/test/java/com/montaury/mus/jeu/MancheTest.java index 78625fb..e02dc15 100644 --- a/src/test/java/com/montaury/mus/jeu/MancheTest.java +++ b/src/test/java/com/montaury/mus/jeu/MancheTest.java @@ -1,5 +1,6 @@ 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; @@ -24,20 +25,29 @@ class MancheTest { @BeforeEach void setUp() { - interfaceJoueurEsku = mock(InterfaceJoueur.class); - interfaceJoueurEsku = mock(InterfaceJoueur.class); - 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); @@ -47,29 +57,39 @@ 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(joueur4); 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 317a58e..d041301 100644 --- a/src/test/java/com/montaury/mus/jeu/PartieTest.java +++ b/src/test/java/com/montaury/mus/jeu/PartieTest.java @@ -1,5 +1,6 @@ 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; @@ -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 d677621..32f7ae0 100644 --- a/src/test/java/com/montaury/mus/jeu/tour/TourTest.java +++ b/src/test/java/com/montaury/mus/jeu/tour/TourTest.java @@ -34,8 +34,8 @@ void setUp() { interfacejoueurEnemie = mock(InterfaceJoueur.class); interfaceJoueurZaku = mock(InterfaceJoueur.class); joueurEsku = new Joueur("J1", interfaceJoueurEsku); - joueurAmi = new Joueur("J3", interfaceJoueurZaku); - joueurEnemie = new Joueur("J2", interfaceJoueurZaku); + 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); @@ -46,7 +46,7 @@ void setUp() { } @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()); @@ -71,6 +71,8 @@ void devrait_repartir_les_points_si_tout_est_paso() { assertThat(score.vainqueur()).isEmpty(); assertThat(score.scoreParJoueur()).containsEntry(joueurEsku, 1); + assertThat(score.scoreParJoueur()).containsEntry(joueurAmi, 5); + assertThat(score.scoreParJoueur()).containsEntry(joueurEnemie, 5); assertThat(score.scoreParJoueur()).containsEntry(joueurZaku, 5); } @@ -78,50 +80,72 @@ void devrait_repartir_les_points_si_tout_est_paso() { 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(joueurEsku, 3); assertThat(score.scoreParJoueur()).containsEntry(joueurZaku, 10); + assertThat(score.scoreParJoueur()).containsEntry(joueurAmi, 10); + assertThat(score.scoreParJoueur()).containsEntry(joueurEnemie, 10); } @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(joueurAmi, 4); + assertThat(score.scoreParJoueur()).containsEntry(joueurEnemie, 16); } @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.AS_COUPE, Carte.DEUX_COUPE, Carte.TROIS_COUPE, Carte.QUATRE_COUPE, + Carte.AS_EPEE, Carte.DEUX_EPEE, Carte.TROIS_EPEE, Carte.QUATRE_EPEE, + Carte.AS_PIECE, Carte.DEUX_PIECE, Carte.TROIS_PIECE, Carte.QUATRE_PIECE + ), new Defausse() + ); tour.jouer(opposants, score); assertThat(score.vainqueur()).isEmpty(); - assertThat(score.scoreParJoueur()).containsEntry(joueurEsku, 7); + assertThat(score.scoreParJoueur()).containsEntry(joueurEsku, 17); assertThat(score.scoreParJoueur()).containsEntry(joueurZaku, 0); + assertThat(score.scoreParJoueur()).containsEntry(joueurAmi, 0); + assertThat(score.scoreParJoueur()).containsEntry(joueurEnemie, 0); } private InterfaceJoueur interfaceJoueurEsku; 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..0a8a1c5 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; @@ -13,8 +14,10 @@ class FauxJeuTest { @Test void ne_doit_pas_se_derouler_si_un_seul_des_joueurs_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.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.AS_EPEE, Carte.DEUX_EPEE, Carte.TROIS_EPEE, 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)); Opposants opposants = new Opposants( - joueurEsku, - unJoueurAvec(main(Carte.VALET_PIECE, Carte.SIX_PIECE, Carte.QUATRE_BATON, Carte.AS_PIECE)) + new Equipe( joueur1, + unJoueurAvec(main(Carte.AS_PIECE, Carte.QUATRE_BATON, Carte.VALET_COUPE, Carte.SIX_BATON))), + new Equipe( unJoueurAvec(main(Carte.AS_EPEE, Carte.QUATRE_EPEE, Carte.VALET_EPEE, Carte.SIX_EPEE)), + unJoueurAvec(main(Carte.AS_COUPE, Carte.QUATRE_COUPE, Carte.VALET_PIECE, Carte.SIX_PIECE))) ); 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..96c4ab9 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,80 @@ 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 Petit().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 Petit().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 Petit().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 Petit().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)); + 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_PIECE, Carte.SIX_EPEE)); + Joueur joueur3 = unJoueurAvec(main(Carte.AS_EPEE, Carte.QUATRE_COUPE, Carte.VALET_COUPE, Carte.SIX_PIECE)); + 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 Petit().meilleurParmi(new Opposants(equipe1, equipe2)); - Joueur vainqueur = new Grand().meilleurParmi(new Opposants(joueurEsku, joueurZaku)); - 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..5f3af84 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); @@ -25,8 +28,10 @@ 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() { 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.VALET_PIECE, Carte.ROI_EPEE, Carte.CAVALIER_COUPE, 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 Petit().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 Petit().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 Petit().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 Petit().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..c92d046 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.DEUX_BATON, Carte.DEUX_COUPE, Carte.DEUX_EPEE, Carte.DEUX_PIECE); + assertThat(joueur3.main().cartes()).containsExactly(Carte.TROIS_BATON, Carte.TROIS_COUPE, Carte.TROIS_EPEE, Carte.TROIS_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(interfaceJoueur2, 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_2_veut_sortir() { + when(interfaceJoueur1.veutAllerMus()).thenReturn(true); + when(interfaceJoueur2.veutAllerMus()).thenReturn(false); mus.jouer(opposants); - verify(interfaceJoueurEsku, times(0)).cartesAJeter(); + verify(interfaceJoueur3, times(0)).veutAllerMus(); } + /* choix du joueur 3 est forcement mus pour pas penaliser le joueur car fait de facon aleatoire + @Test + void devrait_se_terminer_si_le_joueur_3_veut_sortir() { + when(interfaceJoueur1.veutAllerMus()).thenReturn(true); + when(interfaceJoueur2.veutAllerMus()).thenReturn(true); + when(interfaceJoueur3.veutAllerMus()).thenReturn(false); + mus.jouer(opposants); + + verify(interfaceJoueur4, times(0)).veutAllerMus(); + }*/ @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); + 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(interfaceJoueur1, times(0)).cartesAJeter(); + } + + @Test + void devrait_demander_les_cartes_a_jeter_aux_joueurs_s_ils_vont_mus() { + 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.DEUX_COUPE,Carte.TROIS_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.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(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.DEUX_BATON, Carte.DEUX_EPEE, Carte.DEUX_PIECE , Carte.CINQ_COUPE); + assertThat(joueur3.main().cartes()).containsExactly(Carte.TROIS_BATON, Carte.TROIS_EPEE, Carte.TROIS_PIECE , Carte.CINQ_EPEE); + 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..1490816 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.AS_BATON, Carte.SIX_PIECE, Carte.QUATRE_BATON, Carte.AS_PIECE)); 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.QUATRE_PIECE, 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.CINQ_BATON, 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..4984904 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.AS_BATON, Carte.CINQ_EPEE, Carte.CAVALIER_BATON, Carte.SIX_BATON)); + Joueur joueur3 = unJoueurAvec(main(Carte.AS_PIECE, Carte.CINQ_BATON, Carte.CAVALIER_PIECE, Carte.SIX_PIECE)); + 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 From 985c98e60c9aa91dab0bbc64468bb0c45c8834bc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Coussy?= Date: Thu, 25 Mar 2021 04:42:20 +0100 Subject: [PATCH 10/12] =?UTF-8?q?tous=20les=20tests=20fonctionnent=20sauf?= =?UTF-8?q?=201=20correction=20et=20am=C3=A9lioration=20de=20estMeilleur?= =?UTF-8?q?=20de=20paire=20qui=20fonctionne=20correctement=20maintenant?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../montaury/mus/jeu/equipe/Opposants.java | 17 +++-- .../java/com/montaury/mus/jeu/tour/Tour.java | 1 + .../montaury/mus/jeu/tour/phases/FauxJeu.java | 4 +- .../montaury/mus/jeu/tour/phases/Grand.java | 2 +- .../montaury/mus/jeu/tour/phases/Paires.java | 67 +++++++++++++------ .../montaury/mus/jeu/tour/phases/Petit.java | 18 ++--- .../montaury/mus/jeu/tour/phases/Phase.java | 2 +- .../java/com/montaury/mus/jeu/MancheTest.java | 3 +- .../com/montaury/mus/jeu/tour/TourTest.java | 34 ++++------ .../mus/jeu/tour/phases/FauxJeuTest.java | 14 ++-- .../mus/jeu/tour/phases/GrandTest.java | 17 +++-- .../montaury/mus/jeu/tour/phases/JeuTest.java | 12 ++-- .../montaury/mus/jeu/tour/phases/MusTest.java | 30 ++++----- .../mus/jeu/tour/phases/PairesTest.java | 6 +- .../mus/jeu/tour/phases/PetitTest.java | 4 +- 15 files changed, 131 insertions(+), 100 deletions(-) diff --git a/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java b/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java index c112e5f..4e45e22 100644 --- a/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java +++ b/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java @@ -2,24 +2,31 @@ import com.montaury.mus.jeu.joueur.Joueur; +import java.util.ArrayList; 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(joueurEsku()); + joueursDansLordre.add(joueur1equipe2()); + joueursDansLordre.add(joueur2equipe1()); + joueursDansLordre.add(joueurZaku()); } // permet de changer celui qui distribue et celui qui parle en premier public void tourner() { - Equipe equipeTemp = equipe2; - equipe2 = equipe1; - equipe1 = equipeTemp; + Joueur jouerTempon = joueursDansLordre.removeLast(); + joueursDansLordre.addFirst(jouerTempon); } public Joueur joueurEsku() { @@ -40,7 +47,7 @@ public Iterator itererDansLOrdre() { //permet de passer d'un Joueur a l } public List dansLOrdre() { - return List.of(equipe1.joueur1, equipe2.joueur1, equipe1.joueur2, equipe2.joueur2); + return joueursDansLordre; } private static class IteratorInfini implements Iterator { 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 0d06469..6725c2f 100644 --- a/src/main/java/com/montaury/mus/jeu/tour/Tour.java +++ b/src/main/java/com/montaury/mus/jeu/tour/Tour.java @@ -44,6 +44,7 @@ public void jouer(Opposants opposants, Manche.Score score) { Phase.Resultat resultat = phases.next().jouer(affichage, opposants, score); 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 cccecc8..967cd19 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 @@ -27,11 +27,11 @@ protected Joueur meilleurParmi(Opposants opposants) { int pointsMeilleurJoueurEquipe2 = opposants.joueurZaku().main().pointsPourJeu(); Joueur meilleurJoueurEquipe2 = opposants.joueurEsku(); - if (pointsJoueurAllie >= pointsJoueurEsku){ + if (pointsJoueurAllie > pointsJoueurEsku){ pointsMeilleurJoueurEquipe1=pointsJoueurAllie; meilleurJoueurEquipe1 = opposants.joueur2equipe1(); } - if (pointsJoueurEnemie >= pointsJoueurZaku){ + if (pointsJoueurEnemie > pointsJoueurZaku){ pointsMeilleurJoueurEquipe2=pointsJoueurEnemie; meilleurJoueurEquipe2 = opposants.joueur1equipe2(); } 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 87791c7..7262185 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 @@ -22,7 +22,7 @@ protected Joueur meilleurParmi(Opposants opposants) { Joueur joueurZaku = opposants.joueurZaku(); Joueur joueurEquipe1Choisi = null; Joueur joueurEquipe2Choisi = null; - Joueur joueurFinal=null; + Joueur joueurFinal=joueurEsku; List cartesJoueurEsku = joueurEsku.main().cartesDuPlusGrandAuPlusPetit(); 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 3572bbb..bcdb9b5 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 @@ -15,30 +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 pairesJoueurAllie = opposants.joueur2equipe1().main().getPaires(); - com.montaury.mus.jeu.carte.paires.Paires pairesJoueurEnemie = opposants.joueur1equipe2().main().getPaires(); - com.montaury.mus.jeu.carte.paires.Paires pairesJoueurZaku = opposants.joueurZaku().main().getPaires(); - - com.montaury.mus.jeu.carte.paires.Paires pairesMeilleurEquipe1 = opposants.joueurEsku().main().getPaires(); - com.montaury.mus.jeu.carte.paires.Paires pairesMeilleurEquipe2 = opposants.joueurZaku().main().getPaires(); - Joueur meilleurJoueurEquipe1 =opposants.joueurEsku(); - Joueur meilleurJoueurEquipe2=opposants.joueurZaku(); - - if (pairesJoueurEsku.estMeilleureOuEgaleA(pairesJoueurAllie)){ - pairesMeilleurEquipe1=pairesJoueurEsku; - }else { - pairesMeilleurEquipe1=pairesJoueurAllie; + + com.montaury.mus.jeu.carte.paires.Paires meilleurPaireEquie1; + com.montaury.mus.jeu.carte.paires.Paires meilleurPaireEquie2; + opposants.joueurEsku().main().getPaires(); + + Joueur meilleurJoueurEquipe1 = opposants.joueurEsku(); + Joueur meilleurJoueurEquipe2 = opposants.joueurZaku(); + + if(peutParticiper(opposants.joueurEsku()) && peutParticiper(opposants.joueur2equipe1())) + { + //recup le meilleur + if (opposants.joueurEsku().main().getPaires().estMeilleureOuEgaleA(opposants.joueur2equipe1().main().getPaires())){ + meilleurPaireEquie1=opposants.joueurEsku().main().getPaires(); + }else { + meilleurPaireEquie1=opposants.joueur2equipe1().main().getPaires(); + meilleurJoueurEquipe1=opposants.joueur2equipe1(); + } + } + else if(peutParticiper(opposants.joueurEsku())) + { + //recup paire esku + meilleurPaireEquie1 =opposants.joueurEsku().main().getPaires() ; + } + else + { + //recup paire j2e1 + meilleurPaireEquie1 =opposants.joueur2equipe1().main().getPaires() ; meilleurJoueurEquipe1=opposants.joueur2equipe1(); } - if (pairesJoueurZaku.estMeilleureOuEgaleA(pairesJoueurEnemie)){ - pairesMeilleurEquipe2=pairesJoueurZaku; - }else { - pairesMeilleurEquipe2=pairesJoueurEnemie; + if(peutParticiper(opposants.joueurZaku()) && peutParticiper(opposants.joueur1equipe2())) + { + //recup le meilleur + if (opposants.joueurZaku().main().getPaires().estMeilleureOuEgaleA(opposants.joueur2equipe1().main().getPaires())){ + meilleurPaireEquie2 =opposants.joueurZaku().main().getPaires(); + }else { + meilleurPaireEquie2=opposants.joueur1equipe2().main().getPaires(); + meilleurJoueurEquipe2=opposants.joueur1equipe2(); + } + } + else if(peutParticiper(opposants.joueurZaku())) + { + //recup paire zaku + meilleurPaireEquie2 =opposants.joueurZaku().main().getPaires() ; + } + else + { + //recup paire j1e2 + meilleurPaireEquie2 =opposants.joueur1equipe2().main().getPaires() ; meilleurJoueurEquipe2=opposants.joueur1equipe2(); } - return pairesMeilleurEquipe1.estMeilleureOuEgaleA(pairesMeilleurEquipe2) ? meilleurJoueurEquipe1 : meilleurJoueurEquipe2; + + 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 19cb951..656da1b 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 @@ -20,9 +20,11 @@ protected Joueur meilleurParmi(Opposants opposants) { Joueur joueur3 = opposants.joueur2equipe1(); Joueur joueur2 = opposants.joueur1equipe2(); Joueur joueurZaku = opposants.joueurZaku(); - Joueur joueurEquipe1Choisi = null; - Joueur joueurEquipe2Choisi = null; - Joueur joueurFinal=null; + + Joueur joueurEquipe1Choisi = joueurEsku; + Joueur joueurEquipe2Choisi = joueur2; + + Joueur joueurFinal=joueurEsku; List cartesJoueurEsku = joueurEsku.main().cartesDuPlusGrandAuPlusPetit(); List cartesjoueur2 = joueur2.main().cartesDuPlusGrandAuPlusPetit(); @@ -45,6 +47,7 @@ protected Joueur meilleurParmi(Opposants opposants) { break; } } + for (int i = Main.TAILLE - 1; i >= 0; i--) { ValeurCarte.Comparaison compareEquipe2 = cartesjoueur2.get(i).comparerAvec(cartesJoueurZaku.get(i)); if (compareEquipe2 == PLUS_PETITE) { @@ -57,22 +60,19 @@ protected Joueur meilleurParmi(Opposants opposants) { break; } } + 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) { + } + else if (compareEntreEquipe == PLUS_GRANDE) { joueurFinal= joueurEquipe2Choisi; break; - } } 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 694e850..184dc72 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 @@ -62,7 +62,7 @@ public List participantsParmi(Opposants opposants) { } public final boolean peutSeDerouler(Opposants opposants) { - return peutParticiper(opposants.joueurEsku()) && peutParticiper(opposants.joueurZaku()); + return (peutParticiper(opposants.joueurEsku()) || peutParticiper(opposants.joueur2equipe1())) && (peutParticiper(opposants.joueurZaku()) || peutParticiper(opposants.joueur1equipe2())); } protected boolean peutParticiper(Joueur joueur) { diff --git a/src/test/java/com/montaury/mus/jeu/MancheTest.java b/src/test/java/com/montaury/mus/jeu/MancheTest.java index e02dc15..497774e 100644 --- a/src/test/java/com/montaury/mus/jeu/MancheTest.java +++ b/src/test/java/com/montaury/mus/jeu/MancheTest.java @@ -64,12 +64,13 @@ void devrait_terminer_la_manche_si_un_joueur_a_40_points() { Manche.Resultat resultat = manche.jouer(opposants); - assertThat(resultat.vainqueur()).isEqualTo(joueur4); + assertThat(resultat.vainqueur()).isEqualTo(joueur2); assertThat(resultat.pointsVaincu()).isZero(); } @Test void devrait_changer_l_ordre_des_opposants_a_la_fin_du_tour() { + when(interfaceJoueur1.faireChoixParmi(any())).thenReturn(new Hordago()); when(interfaceJoueur2.faireChoixParmi(any())).thenReturn(new Kanta()); when(interfaceJoueur3.faireChoixParmi(any())).thenReturn(new Kanta()); 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 32f7ae0..2a268ad 100644 --- a/src/test/java/com/montaury/mus/jeu/tour/TourTest.java +++ b/src/test/java/com/montaury/mus/jeu/tour/TourTest.java @@ -70,10 +70,10 @@ void devrait_repartir_les_points_si_tout_est_paso() { tour.jouer(opposants, score); assertThat(score.vainqueur()).isEmpty(); - assertThat(score.scoreParJoueur()).containsEntry(joueurEsku, 1); - assertThat(score.scoreParJoueur()).containsEntry(joueurAmi, 5); - assertThat(score.scoreParJoueur()).containsEntry(joueurEnemie, 5); - 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 @@ -102,10 +102,10 @@ void devrait_partager_les_points_si_tout_est_idoki() { tour.jouer(opposants, score); assertThat(score.vainqueur()).isEmpty(); - assertThat(score.scoreParJoueur()).containsEntry(joueurEsku, 3); - assertThat(score.scoreParJoueur()).containsEntry(joueurZaku, 10); - assertThat(score.scoreParJoueur()).containsEntry(joueurAmi, 10); - assertThat(score.scoreParJoueur()).containsEntry(joueurEnemie, 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 @@ -119,10 +119,10 @@ void devrait_partager_les_points_si_tout_est_gehiago_puis_idoki() { tour.jouer(opposants, score); assertThat(score.vainqueur()).isEmpty(); - assertThat(score.scoreParJoueur()).containsEntry(joueurEsku, 4); - assertThat(score.scoreParJoueur()).containsEntry(joueurZaku, 16); - assertThat(score.scoreParJoueur()).containsEntry(joueurAmi, 4); - assertThat(score.scoreParJoueur()).containsEntry(joueurEnemie, 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 @@ -132,15 +132,9 @@ void devrait_privilegier_le_joueur_esku_si_les_mains_sont_identiques() { 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, - Carte.AS_EPEE, Carte.DEUX_EPEE, Carte.TROIS_EPEE, Carte.QUATRE_EPEE, - Carte.AS_PIECE, Carte.DEUX_PIECE, Carte.TROIS_PIECE, Carte.QUATRE_PIECE - ), new Defausse() - ); - + 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 + ,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.jouer(opposants, score); - assertThat(score.vainqueur()).isEmpty(); assertThat(score.scoreParJoueur()).containsEntry(joueurEsku, 17); assertThat(score.scoreParJoueur()).containsEntry(joueurZaku, 0); 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 0a8a1c5..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 @@ -12,11 +12,11 @@ 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( 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)), + 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))) ); @@ -57,12 +57,12 @@ void devrait_faire_gagner_le_joueur_ayant_le_plus_grand_nombre_de_points() { @Test void devrait_faire_gagner_le_joueur_esku_en_cas_d_egalite() { 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( - new Equipe( joueur1, - unJoueurAvec(main(Carte.AS_PIECE, Carte.QUATRE_BATON, Carte.VALET_COUPE, Carte.SIX_BATON))), - new Equipe( unJoueurAvec(main(Carte.AS_EPEE, Carte.QUATRE_EPEE, Carte.VALET_EPEE, Carte.SIX_EPEE)), - unJoueurAvec(main(Carte.AS_COUPE, Carte.QUATRE_COUPE, Carte.VALET_PIECE, Carte.SIX_PIECE))) - ); + new Equipe( joueur1,joueur2), + new Equipe(joueur3 ,joueur4)); Joueur vainqueur = new FauxJeu().meilleurParmi(opposants); 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 96c4ab9..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 @@ -20,7 +20,7 @@ void devrait_faire_gagner_le_joueur_4_s_il_a_la_plus_grande_carte() { Equipe equipe1 = new Equipe(joueur1,joueur2); Equipe equipe2 = new Equipe(joueur3,joueur4); - Joueur vainqueur = new Petit().meilleurParmi(new Opposants(equipe1, equipe2)); + Joueur vainqueur = new Grand().meilleurParmi(new Opposants(equipe1, equipe2)); assertThat(vainqueur).isEqualTo(joueur4); } @Test @@ -32,7 +32,7 @@ void devrait_faire_gagner_le_joueur_3_s_il_a_la_plus_grande_carte() { Equipe equipe1 = new Equipe(joueur1,joueur2); Equipe equipe2 = new Equipe(joueur3,joueur4); - Joueur vainqueur = new Petit().meilleurParmi(new Opposants(equipe1, equipe2)); + Joueur vainqueur = new Grand().meilleurParmi(new Opposants(equipe1, equipe2)); assertThat(vainqueur).isEqualTo(joueur3); } @Test @@ -44,7 +44,7 @@ void devrait_faire_gagner_le_joueur_2_s_il_a_la_plus_grande_carte() { Equipe equipe1 = new Equipe(joueur1,joueur2); Equipe equipe2 = new Equipe(joueur3,joueur4); - Joueur vainqueur = new Petit().meilleurParmi(new Opposants(equipe1, equipe2)); + Joueur vainqueur = new Grand().meilleurParmi(new Opposants(equipe1, equipe2)); assertThat(vainqueur).isEqualTo(joueur2); } @Test @@ -69,22 +69,21 @@ void devrait_faire_gagner_le_joueur_qui_a_la_seconde_plus_grande_carte_si_la_pre Equipe equipe1 = new Equipe(joueur1,joueur2); Equipe equipe2 = new Equipe(joueur3,joueur4); - Joueur vainqueur = new Petit().meilleurParmi(new Opposants(equipe1, equipe2)); + Joueur vainqueur = new Grand().meilleurParmi(new Opposants(equipe1, equipe2)); assertThat(vainqueur).isEqualTo(joueur4); } @Test - void devrait_faire_gagner_le_joueur_esku_si_les_deux_mains_sont_egales() { + 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_PIECE, Carte.QUATRE_BATON, Carte.VALET_PIECE, Carte.SIX_EPEE)); - Joueur joueur3 = unJoueurAvec(main(Carte.AS_EPEE, Carte.QUATRE_COUPE, Carte.VALET_COUPE, Carte.SIX_PIECE)); + 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 Petit().meilleurParmi(new Opposants(equipe1, equipe2)); - + Joueur vainqueur = new Grand().meilleurParmi(new Opposants(equipe1, equipe2)); assertThat(vainqueur).isEqualTo(joueur1); } 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 5f3af84..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 @@ -26,10 +26,10 @@ 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( new Equipe( unJoueurAvec(main(Carte.AS_BATON, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)), - unJoueurAvec(main(Carte.VALET_PIECE, Carte.ROI_EPEE, Carte.CAVALIER_COUPE, Carte.AS_PIECE))), + 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))) ); @@ -62,7 +62,7 @@ void devrait_faire_gagner_le_joueur_ayant_31_par_rapport_a_32() { Equipe equipe1 = new Equipe(joueur1,joueur2); Equipe equipe2 = new Equipe(joueur3,joueur4); - Joueur vainqueur = new Petit().meilleurParmi(new Opposants(equipe1, equipe2)); + Joueur vainqueur = new Jeu().meilleurParmi(new Opposants(equipe1, equipe2)); assertThat(vainqueur).isEqualTo(joueur1); } @@ -75,7 +75,7 @@ void devrait_faire_gagner_le_joueur_ayant_40_par_rapport_a_37() { Equipe equipe1 = new Equipe(joueur1,joueur2); Equipe equipe2 = new Equipe(joueur3,joueur4); - Joueur vainqueur = new Petit().meilleurParmi(new Opposants(equipe1, equipe2)); + Joueur vainqueur = new Jeu().meilleurParmi(new Opposants(equipe1, equipe2)); assertThat(vainqueur).isEqualTo(joueur1); } @@ -88,7 +88,7 @@ void devrait_faire_gagner_le_joueur_ayant_36_par_rapport_a_33() { Equipe equipe1 = new Equipe(joueur1,joueur2); Equipe equipe2 = new Equipe(joueur3,joueur4); - Joueur vainqueur = new Petit().meilleurParmi(new Opposants(equipe1, equipe2)); + Joueur vainqueur = new Jeu().meilleurParmi(new Opposants(equipe1, equipe2)); assertThat(vainqueur).isEqualTo(joueur1); } @@ -101,7 +101,7 @@ void devrait_faire_gagner_le_joueur_esku_en_cas_d_egalite() { Equipe equipe1 = new Equipe(joueur1,joueur2); Equipe equipe2 = new Equipe(joueur3,joueur4); - Joueur vainqueur = new Petit().meilleurParmi(new Opposants(equipe1, equipe2)); + Joueur vainqueur = new Jeu().meilleurParmi(new Opposants(equipe1, equipe2)); assertThat(vainqueur).isEqualTo(joueur1); } 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 c92d046..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 @@ -46,8 +46,8 @@ void devrait_distribuer_quatre_cartes_a_chaque_joueur() { mus.jouer(opposants); assertThat(joueur1.main().cartes()).containsExactly(Carte.AS_BATON, Carte.AS_COUPE, Carte.AS_EPEE, Carte.AS_PIECE); - assertThat(joueur2.main().cartes()).containsExactly(Carte.DEUX_BATON, Carte.DEUX_COUPE, Carte.DEUX_EPEE, Carte.DEUX_PIECE); - assertThat(joueur3.main().cartes()).containsExactly(Carte.TROIS_BATON, Carte.TROIS_COUPE, Carte.TROIS_EPEE, Carte.TROIS_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); } @@ -57,28 +57,28 @@ void devrait_se_terminer_si_le_joueur_1_veut_sortir() { mus.jouer(opposants); - verify(interfaceJoueur2, 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(interfaceJoueur3, times(0)).veutAllerMus(); - } - /* choix du joueur 3 est forcement mus pour pas penaliser le joueur car fait de facon aleatoire + verify(interfaceJoueur4, times(0)).veutAllerMus(); + }*/ + @Test void devrait_se_terminer_si_le_joueur_3_veut_sortir() { when(interfaceJoueur1.veutAllerMus()).thenReturn(true); - when(interfaceJoueur2.veutAllerMus()).thenReturn(true); when(interfaceJoueur3.veutAllerMus()).thenReturn(false); mus.jouer(opposants); - verify(interfaceJoueur4, times(0)).veutAllerMus(); - }*/ + verify(interfaceJoueur2, times(0)).veutAllerMus(); + } @Test void devrait_se_terminer_si_le_joueur_4_veut_sortir() { @@ -118,7 +118,7 @@ void devrait_defausser_les_cartes_a_jeter_si_les_joueurs_vont_mus() { mus.jouer(opposants); - assertThat(defausse.reprendreCartes()).containsExactly(Carte.AS_COUPE, Carte.DEUX_COUPE,Carte.TROIS_COUPE,Carte.QUATRE_COUPE); + assertThat(defausse.reprendreCartes()).containsExactly(Carte.AS_COUPE, Carte.TROIS_COUPE, Carte.DEUX_COUPE,Carte.QUATRE_COUPE); } @Test @@ -126,17 +126,17 @@ void devrait_distribuer_des_cartes_pour_remplacer_les_cartes_jetees_si_les_joueu 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(interfaceJoueur2.cartesAJeter()).thenReturn(List.of(Carte.TROIS_COUPE)); when(interfaceJoueur3.veutAllerMus()).thenReturn(true); - when(interfaceJoueur3.cartesAJeter()).thenReturn(List.of(Carte.TROIS_COUPE)); + 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(joueur1.main().cartes()).containsExactly(Carte.AS_BATON, Carte.AS_EPEE, Carte.AS_PIECE , Carte.CINQ_BATON); - assertThat(joueur2.main().cartes()).containsExactly(Carte.DEUX_BATON, Carte.DEUX_EPEE, Carte.DEUX_PIECE , Carte.CINQ_COUPE); - assertThat(joueur3.main().cartes()).containsExactly(Carte.TROIS_BATON, Carte.TROIS_EPEE, Carte.TROIS_PIECE , Carte.CINQ_EPEE); + 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); } 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 1490816..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 @@ -55,12 +55,12 @@ void devrait_se_derouler_si_un_joueur_de_chaque_equipe_ont_un_ou_des_paires() { @Test void devrait_faire_gagner_le_joueur_ayant_la_meilleure_paire() { - Joueur j2=unJoueurAvec(main(Carte.AS_BATON, Carte.SIX_PIECE, Carte.QUATRE_BATON, Carte.AS_PIECE)); + Joueur j2=unJoueurAvec(main(Carte.ROI_EPEE, Carte.SIX_PIECE, Carte.QUATRE_BATON, Carte.ROI_EPEE)); Opposants opposants = new Opposants( - new Equipe( unJoueurAvec(main(Carte.DEUX_COUPE, Carte.QUATRE_PIECE, Carte.VALET_BATON, Carte.SIX_COUPE)), + 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.CINQ_BATON, Carte.AS_EPEE))) + unJoueurAvec(main(Carte.ROI_BATON, Carte.TROIS_PIECE, Carte.TROIS_PIECE, Carte.AS_EPEE))) ); Joueur vainqueur = new Paires().meilleurParmi(opposants); 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 4984904..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 @@ -90,8 +90,8 @@ void devrait_faire_gagner_le_joueur_qui_a_la_seconde_plus_petite_carte_si_la_pre @Test void devrait_faire_gagner_le_joueur_esku_si_les_deux_mains_sont_egales() { Joueur joueur1 = unJoueurAvec(main(Carte.AS_PIECE, Carte.CINQ_PIECE, Carte.CAVALIER_EPEE, Carte.SIX_COUPE)); - Joueur joueur2 = unJoueurAvec(main(Carte.AS_BATON, Carte.CINQ_EPEE, Carte.CAVALIER_BATON, Carte.SIX_BATON)); - Joueur joueur3 = unJoueurAvec(main(Carte.AS_PIECE, Carte.CINQ_BATON, Carte.CAVALIER_PIECE, Carte.SIX_PIECE)); + 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); From a164548ccc25ff83e5b90757840635405225bdcd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Coussy?= Date: Thu, 25 Mar 2021 05:18:22 +0100 Subject: [PATCH 11/12] =?UTF-8?q?tous=20les=20tests=20fonctionnent=20sauf?= =?UTF-8?q?=201=20correction=20et=20am=C3=A9lioration=20de=20estMeilleur?= =?UTF-8?q?=20de=20paire=20qui=20fonctionne=20correctement=20maintenant?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/com/montaury/mus/jeu/tour/Tour.java | 2 +- src/test/java/com/montaury/mus/jeu/tour/TourTest.java | 10 ++++++---- 2 files changed, 7 insertions(+), 5 deletions(-) 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 6725c2f..3f94f7a 100644 --- a/src/main/java/com/montaury/mus/jeu/tour/Tour.java +++ b/src/main/java/com/montaury/mus/jeu/tour/Tour.java @@ -41,7 +41,7 @@ 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()); 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 2a268ad..d6f917b 100644 --- a/src/test/java/com/montaury/mus/jeu/tour/TourTest.java +++ b/src/test/java/com/montaury/mus/jeu/tour/TourTest.java @@ -132,13 +132,15 @@ void devrait_privilegier_le_joueur_esku_si_les_mains_sont_identiques() { 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 - ,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, 17); + assertThat(score.scoreParJoueur()).containsEntry(joueurEsku, 4); assertThat(score.scoreParJoueur()).containsEntry(joueurZaku, 0); - assertThat(score.scoreParJoueur()).containsEntry(joueurAmi, 0); + assertThat(score.scoreParJoueur()).containsEntry(joueurAmi, 3); assertThat(score.scoreParJoueur()).containsEntry(joueurEnemie, 0); } From 61401548e6f359607d51f941e4c648f30684fafe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Coussy?= Date: Thu, 25 Mar 2021 10:22:04 +0100 Subject: [PATCH 12/12] rotation --- .../java/com/montaury/mus/jeu/Manche.java | 8 ++-- .../java/com/montaury/mus/jeu/Partie.java | 8 ++-- .../montaury/mus/jeu/equipe/Opposants.java | 23 +++++----- .../AffichageConsoleEvenementsDeJeu.java | 2 +- .../montaury/mus/jeu/tour/phases/FauxJeu.java | 20 ++++----- .../montaury/mus/jeu/tour/phases/Grand.java | 8 ++-- .../com/montaury/mus/jeu/tour/phases/Jeu.java | 6 +-- .../montaury/mus/jeu/tour/phases/Paires.java | 42 +++++++++---------- .../montaury/mus/jeu/tour/phases/Petit.java | 8 ++-- .../montaury/mus/jeu/tour/phases/Phase.java | 3 +- 10 files changed, 64 insertions(+), 64 deletions(-) diff --git a/src/main/java/com/montaury/mus/jeu/Manche.java b/src/main/java/com/montaury/mus/jeu/Manche.java index 199eb7d..05c15cd 100644 --- a/src/main/java/com/montaury/mus/jeu/Manche.java +++ b/src/main/java/com/montaury/mus/jeu/Manche.java @@ -32,10 +32,10 @@ public static class Score { private final Map scoreParJoueur = new HashMap<>(); public Score(Opposants opposants) { - scoreParJoueur.put(opposants.joueurEsku(), 0); - scoreParJoueur.put(opposants.joueur1equipe2(), 0); - scoreParJoueur.put(opposants.joueur2equipe1(), 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); } diff --git a/src/main/java/com/montaury/mus/jeu/Partie.java b/src/main/java/com/montaury/mus/jeu/Partie.java index dde1d50..fd8f0d8 100644 --- a/src/main/java/com/montaury/mus/jeu/Partie.java +++ b/src/main/java/com/montaury/mus/jeu/Partie.java @@ -35,10 +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.joueur1equipe2(), 0); - this.manchesGagneesParJoueur.put(opposants.joueur2equipe1(), 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/Opposants.java b/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java index 4e45e22..0d453ee 100644 --- a/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java +++ b/src/main/java/com/montaury/mus/jeu/equipe/Opposants.java @@ -2,7 +2,6 @@ import com.montaury.mus.jeu.joueur.Joueur; -import java.util.ArrayList; import java.util.Iterator; import java.util.LinkedList; @@ -18,27 +17,29 @@ public Opposants(Equipe equipe1, Equipe equipe2) { this.equipe1 = equipe1; this.equipe2 = equipe2; joueursDansLordre = new LinkedList(); - joueursDansLordre.add(joueurEsku()); - joueursDansLordre.add(joueur1equipe2()); - joueursDansLordre.add(joueur2equipe1()); - joueursDansLordre.add(joueurZaku()); + 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 joueurEsku() { + public Joueur joueur1() { return equipe1.joueur1; } - public Joueur joueur2equipe1() { - return equipe1.joueur2; - } - public Joueur joueur1equipe2() { + public Joueur joueur2() {return equipe1.joueur2;} + public Joueur joueur3() { return equipe2.joueur1; } - public Joueur joueurZaku() { + public Joueur joueur4() { return equipe2.joueur2; } 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 f0bc088..9f2daf2 100644 --- a/src/main/java/com/montaury/mus/jeu/joueur/AffichageConsoleEvenementsDeJeu.java +++ b/src/main/java/com/montaury/mus/jeu/joueur/AffichageConsoleEvenementsDeJeu.java @@ -33,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/tour/phases/FauxJeu.java b/src/main/java/com/montaury/mus/jeu/tour/phases/FauxJeu.java index 967cd19..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 @@ -17,23 +17,23 @@ protected boolean peutParticiper(Joueur joueur) { @Override protected Joueur meilleurParmi(Opposants opposants) { - int pointsJoueurEsku = opposants.joueurEsku().main().pointsPourJeu(); - int pointsJoueurAllie = opposants.joueur1equipe2().main().pointsPourJeu(); - int pointsJoueurEnemie = opposants.joueur2equipe1().main().pointsPourJeu(); - int pointsJoueurZaku = opposants.joueurZaku().main().pointsPourJeu(); + 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.joueurEsku().main().pointsPourJeu(); - Joueur meilleurJoueurEquipe1 = opposants.joueurEsku(); - int pointsMeilleurJoueurEquipe2 = opposants.joueurZaku().main().pointsPourJeu(); - Joueur meilleurJoueurEquipe2 = opposants.joueurEsku(); + 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.joueur2equipe1(); + meilleurJoueurEquipe1 = opposants.joueur2(); } if (pointsJoueurEnemie > pointsJoueurZaku){ pointsMeilleurJoueurEquipe2=pointsJoueurEnemie; - meilleurJoueurEquipe2 = opposants.joueur1equipe2(); + meilleurJoueurEquipe2 = opposants.joueur3(); } 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 7262185..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 @@ -16,10 +16,10 @@ public Grand() { @Override protected Joueur meilleurParmi(Opposants opposants) { - Joueur joueurEsku = opposants.joueurEsku(); - Joueur joueur3 = opposants.joueur2equipe1(); - Joueur joueur2 = opposants.joueur1equipe2(); - 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; 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 99e7b50..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 @@ -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/Paires.java b/src/main/java/com/montaury/mus/jeu/tour/phases/Paires.java index bcdb9b5..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 @@ -18,53 +18,53 @@ protected Joueur meilleurParmi(Opposants opposants) { com.montaury.mus.jeu.carte.paires.Paires meilleurPaireEquie1; com.montaury.mus.jeu.carte.paires.Paires meilleurPaireEquie2; - opposants.joueurEsku().main().getPaires(); + opposants.joueur1().main().getPaires(); - Joueur meilleurJoueurEquipe1 = opposants.joueurEsku(); - Joueur meilleurJoueurEquipe2 = opposants.joueurZaku(); + Joueur meilleurJoueurEquipe1 = opposants.joueur1(); + Joueur meilleurJoueurEquipe2 = opposants.joueur4(); - if(peutParticiper(opposants.joueurEsku()) && peutParticiper(opposants.joueur2equipe1())) + if(peutParticiper(opposants.joueur1()) && peutParticiper(opposants.joueur2())) { //recup le meilleur - if (opposants.joueurEsku().main().getPaires().estMeilleureOuEgaleA(opposants.joueur2equipe1().main().getPaires())){ - meilleurPaireEquie1=opposants.joueurEsku().main().getPaires(); + if (opposants.joueur1().main().getPaires().estMeilleureOuEgaleA(opposants.joueur2().main().getPaires())){ + meilleurPaireEquie1=opposants.joueur1().main().getPaires(); }else { - meilleurPaireEquie1=opposants.joueur2equipe1().main().getPaires(); - meilleurJoueurEquipe1=opposants.joueur2equipe1(); + meilleurPaireEquie1=opposants.joueur2().main().getPaires(); + meilleurJoueurEquipe1=opposants.joueur2(); } } - else if(peutParticiper(opposants.joueurEsku())) + else if(peutParticiper(opposants.joueur1())) { //recup paire esku - meilleurPaireEquie1 =opposants.joueurEsku().main().getPaires() ; + meilleurPaireEquie1 =opposants.joueur1().main().getPaires() ; } else { //recup paire j2e1 - meilleurPaireEquie1 =opposants.joueur2equipe1().main().getPaires() ; - meilleurJoueurEquipe1=opposants.joueur2equipe1(); + meilleurPaireEquie1 =opposants.joueur2().main().getPaires() ; + meilleurJoueurEquipe1=opposants.joueur2(); } - if(peutParticiper(opposants.joueurZaku()) && peutParticiper(opposants.joueur1equipe2())) + if(peutParticiper(opposants.joueur4()) && peutParticiper(opposants.joueur3())) { //recup le meilleur - if (opposants.joueurZaku().main().getPaires().estMeilleureOuEgaleA(opposants.joueur2equipe1().main().getPaires())){ - meilleurPaireEquie2 =opposants.joueurZaku().main().getPaires(); + if (opposants.joueur4().main().getPaires().estMeilleureOuEgaleA(opposants.joueur2().main().getPaires())){ + meilleurPaireEquie2 =opposants.joueur4().main().getPaires(); }else { - meilleurPaireEquie2=opposants.joueur1equipe2().main().getPaires(); - meilleurJoueurEquipe2=opposants.joueur1equipe2(); + meilleurPaireEquie2=opposants.joueur3().main().getPaires(); + meilleurJoueurEquipe2=opposants.joueur3(); } } - else if(peutParticiper(opposants.joueurZaku())) + else if(peutParticiper(opposants.joueur4())) { //recup paire zaku - meilleurPaireEquie2 =opposants.joueurZaku().main().getPaires() ; + meilleurPaireEquie2 =opposants.joueur4().main().getPaires() ; } else { //recup paire j1e2 - meilleurPaireEquie2 =opposants.joueur1equipe2().main().getPaires() ; - meilleurJoueurEquipe2=opposants.joueur1equipe2(); + meilleurPaireEquie2 =opposants.joueur3().main().getPaires() ; + meilleurJoueurEquipe2=opposants.joueur3(); } return meilleurPaireEquie1.estMeilleureOuEgaleA(meilleurPaireEquie2) ? meilleurJoueurEquipe1 : meilleurJoueurEquipe2; 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 656da1b..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 @@ -16,10 +16,10 @@ public Petit() { @Override protected Joueur meilleurParmi(Opposants opposants) { - Joueur joueurEsku = opposants.joueurEsku(); - Joueur joueur3 = opposants.joueur2equipe1(); - Joueur joueur2 = opposants.joueur1equipe2(); - 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; 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 184dc72..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 @@ -4,7 +4,6 @@ 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.equipe.Opposants; import com.montaury.mus.jeu.tour.phases.dialogue.Dialogue; import com.montaury.mus.jeu.tour.phases.dialogue.DialogueTermine; import java.util.List; @@ -62,7 +61,7 @@ public List participantsParmi(Opposants opposants) { } public final boolean peutSeDerouler(Opposants opposants) { - return (peutParticiper(opposants.joueurEsku()) || peutParticiper(opposants.joueur2equipe1())) && (peutParticiper(opposants.joueurZaku()) || peutParticiper(opposants.joueur1equipe2())); + return (peutParticiper(opposants.joueur1()) || peutParticiper(opposants.joueur2())) && (peutParticiper(opposants.joueur4()) || peutParticiper(opposants.joueur3())); } protected boolean peutParticiper(Joueur joueur) {