Amélioration de la structure/sémantique et des fonctionnalitées; Appli non fonctionnelle -> problème de binding

TheGameExtreme/model/Card.cs

@@ -1,13 +1,29 @@
 using System;
+using System.ComponentModel;
 
 namespace TheGameExtreme.model
 {
-    public class Card
+    public class Card : INotifyPropertyChanged
     {
 
-        public int Value { get; private set;}
+        public event PropertyChangedEventHandler PropertyChanged;
+        private int value;
+        public int Value
+        {
+            get { return value; }
+            set {
+                this.value = value;
+                OnPropertyChange("Value");
+            }
+        }
+        private void OnPropertyChange(string v)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(v));
+        }
+
         public Effect Effect { get; private set; }
 
+
         public Card(int value)
         {
             Value = value;

TheGameExtreme/model/Player.cs

@@ -21,13 +21,15 @@ namespace TheGameExtreme.model
         public void pioche(Card card)
         {
             cardList.Add(card);
-            OnCardDrawable(new HandCardChangedEventArgs(card, null));
+            int position = cardList.IndexOf(card);
+            OnCardDrawable(new HandCardChangedEventArgs(card, position));
         }
 
         public void joue(Card card)
         {
+            int position = cardList.IndexOf(card);
             cardList.Remove(card);
-            OnCardDrawable(new HandCardChangedEventArgs(null, card));
+            OnCardDrawable(new HandCardChangedEventArgs(null, position));
         }
 
         //public IReadOnlyList<Card> getCardList()

TheGameExtreme/model/event/CurrentHandChangedEventArgs.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+
+namespace TheGameExtreme.model.@event
+{
+    public class HandCardChangedEventArgs
+    {
+
+        public Card NewCard { get; set; }
+        public int Position { get; set; }
+
+        public HandCardChangedEventArgs(Card newCard, int position)
+        {
+            NewCard = newCard;
+            Position = position;
+        }
+    }
+}

TheGameExtreme/model/event/HandCardChangedEventArgs.cs

@@ -1,16 +0,0 @@
-using System;
-namespace TheGameExtreme.model.@event
-{
-    public class HandCardChangedEventArgs
-    {
-
-        public Card NewHandCard { get; set; }
-        public Card OldHandCard { get; set; }
-
-        public HandCardChangedEventArgs(Card newHandCard, Card oldHandCard)
-        {
-            NewHandCard = newHandCard;
-            OldHandCard = oldHandCard;
-        }
-    }
-}

TheGameExtreme/model/event/PlayerChangedEventArgs.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+
+namespace TheGameExtreme.model.@event
+{
+    public class PlayerChangedEventArgs : EventArgs
+    {
+
+        public List<Card> NewCurrentHand;
+
+        public PlayerChangedEventArgs(List<Card> newCurrentHand)
+        {
+            NewCurrentHand = newCurrentHand;
+        }
+    }
+}

TheGameExtreme/model/manager/GameManager.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using TheGameExtreme.model.effect;
 using TheGameExtreme.model.@event;
 
@@ -10,34 +11,48 @@ namespace TheGameExtreme.model.manager
 
         public readonly int nbPlayer;
         protected int nbMaxCard;
-        protected int currentIndexPlayer = 0;
+        protected int currentIndexPlayer;
         protected List<Player> playerList = new List<Player>();
         protected List<InfiniteEffect> infiniteEffectsConstraintsList = new List<InfiniteEffect>();
-        protected List<Stack<Card>> listOrderedStacks = new List<Stack<Card>>();
+        public List<Stack<Card>> ListOrderedStacks { get; set; }
         protected List<Card> deck = new List<Card>();
         protected bool win = true;
         public event EventHandler<TopRangeChangedEventArgs> TopRangeChanged;
-        public event EventHandler<CurrentPlayerChangedEventArgs> CurrentPlayerChanged;
+        public event EventHandler<PlayerChangedEventArgs> PlayerChanged;
+        //public event EventHandler<CurrentPlayerChangedEventArgs> CurrentPlayerChanged;
+        public List<Card> CurrentHand { get; set; }
 
-        public GameManager(int nbPlayer, List<Player> players)
+
+        public GameManager(int nbPlayer, List<String> players)
         {
+            ListOrderedStacks = new List<Stack<Card>>();
+            CurrentHand = new List<Card>();
+
             this.nbPlayer = nbPlayer;
-            players.ForEach(player => playerList.Add(player));
+            players.ForEach(player => playerList.Add(new Player(player)));
+
+            ListOrderedStacks.Add(new Stack<Card>());
+            ListOrderedStacks.Add(new Stack<Card>());
+            ListOrderedStacks.Add(new Stack<Card>());
+            ListOrderedStacks.Add(new Stack<Card>());
+
             for (int i = 0; i < 4; i++)
             {
-                listOrderedStacks.Add(new Stack<Card>());
                 if (i < 2)
                 {
-                    listOrderedStacks[i].Push(new Card(100));
+                    ListOrderedStacks[i].Push(new Card(1));
                 }
                 else
                 {
-                    listOrderedStacks[i].Push(new Card(1));
+                    ListOrderedStacks[i].Push(new Card(100));
                 }
             }
+
             createDeck();
             defineNbMaxCard();
             distribueCard();
+
+            CurrentHand = playerList[currentIndexPlayer].getCardList();
         }
 
         protected void createDeck()
@@ -94,19 +109,26 @@ namespace TheGameExtreme.model.manager
             }
         }
 
-        public void joue(Card card, int orderedStackSelected)
+        public void joue(int valueCard, int orderedStackSelected)
+        {
+            CurrentHand.ForEach(card =>
+            {
+                if (valueCard == card.Value)
                 {
                     if (orderedStackSelected >= 0 && orderedStackSelected < 4)
                     {
                         if (orderedStackSelected < 2)
                         {
-                    testPossibility(card, listOrderedStacks[orderedStackSelected], false);
+                            testPossibility(card, ListOrderedStacks[orderedStackSelected], false);
                         }
                         else
                         {
-                    testPossibility(card, listOrderedStacks[orderedStackSelected], true);
+                            testPossibility(card, ListOrderedStacks[orderedStackSelected], true);
                         }
                     }
+                    return;
+                }
+            });
         }
 
         protected void testPossibility(Card card, Stack<Card> orderedStack, bool bottomUp)
@@ -116,11 +138,11 @@ namespace TheGameExtreme.model.manager
                 Card oldCard = orderedStack.Peek();
                 playerList[currentIndexPlayer].joue(card);
                 orderedStack.Push(card);
-                OnTopRangeChanged(new TopRangeChangedEventArgs(card, oldCard, listOrderedStacks.IndexOf(orderedStack)));
+                OnTopRangeChanged(new TopRangeChangedEventArgs(card, oldCard, ListOrderedStacks.IndexOf(orderedStack)));
             }
             else
             {
-                // Throw Exception
+                throw new Exception("La carte ne rentre pas dans la pile sectionné!");
             }
         }
 
@@ -129,9 +151,26 @@ namespace TheGameExtreme.model.manager
             TopRangeChanged?.Invoke(this, args);
         }
 
-        protected internal void OnCurrentPlayerChanged(CurrentPlayerChangedEventArgs args)
+        protected internal void OnPlayerChanged(PlayerChangedEventArgs args)
         {
-            CurrentPlayerChanged?.Invoke(this, args);
+            PlayerChanged?.Invoke(this, args);
+        }
+
+        //protected internal void OnCurrentPlayerChanged(CurrentPlayerChangedEventArgs args)
+        //{
+        //    CurrentPlayerChanged?.Invoke(this, args);
+        //}
+
+        public bool isCanPlay()
+        {
+            if (CurrentHand.Count > 0)
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
         }
 
         abstract public void endTurn();
@@ -140,7 +179,7 @@ namespace TheGameExtreme.model.manager
 
         abstract protected bool isEndGame();
 
-        abstract protected List<Card> tryToFindSoluce(List<Card> playableCard, Player currentPlayer);
+        abstract protected void tryToFindSoluce(List<Card> playableCard);
 
         abstract protected bool testEndGame(List<Card> playableCard);
 

TheGameExtreme/model/manager/SoloGameManager.cs

@@ -8,7 +8,7 @@ namespace TheGameExtreme.model.manager
     public class SoloGameManager : GameManager
     {
 
-        public SoloGameManager(int nbPlayer, List<Player> players)
+        public SoloGameManager(int nbPlayer, List<String> players)
             : base(nbPlayer, players)
         {
 
@@ -23,7 +23,8 @@ namespace TheGameExtreme.model.manager
             {
                 currentIndexPlayer = 0;
             }
-            OnCurrentPlayerChanged(new CurrentPlayerChangedEventArgs(currentIndexPlayer));
+            CurrentHand = playerList[currentIndexPlayer].getCardList();
+            OnPlayerChanged(new PlayerChangedEventArgs(CurrentHand));
 
             if (isEndGame())    // Ajouter le score en calculant les cartes restantes dans la pile et dans les mains des joueurs
             {
@@ -40,7 +41,7 @@ namespace TheGameExtreme.model.manager
 
         protected override void pioche()
         {
-            int nbPickedCard = nbMaxCard - playerList[currentIndexPlayer].getCardList().Count;
+            int nbPickedCard = nbMaxCard - CurrentHand.Count;
             for (int i = 0; i < nbPickedCard; i++)
             {
                 int random = new Random().Next(0, deck.Count - 1);
@@ -51,11 +52,10 @@ namespace TheGameExtreme.model.manager
 
         protected override bool isEndGame()
         {
-            Player currentPlayer = playerList[currentIndexPlayer];
+            if (CurrentHand.Count != 0)
-            if (currentPlayer.getCardList().Count != 0)
             {
                 List<Card> playableCard = new List<Card>();
-                tryToFindSoluce(playableCard, currentPlayer);
+                tryToFindSoluce(playableCard);
                 return testEndGame(playableCard);
             }
             return false;
@@ -103,18 +103,15 @@ namespace TheGameExtreme.model.manager
             //});
         }
 
-        protected override List<Card> tryToFindSoluce(List<Card> playableCard, Player currentPlayer)
+        protected override void tryToFindSoluce(List<Card> playableCard)
         {
-            List<Card> cardList = new List<Card>(currentPlayer.getCardList());
+            CurrentHand.ForEach(card =>
-            cardList.ForEach(card =>
             {
-                if (card.Value < listOrderedStacks[0].Peek().Value || card.Value < listOrderedStacks[1].Peek().Value || card.Value > listOrderedStacks[2].Peek().Value || card.Value > listOrderedStacks[3].Peek().Value)
+                if (card.Value < ListOrderedStacks[0].Peek().Value || card.Value < ListOrderedStacks[1].Peek().Value || card.Value > ListOrderedStacks[2].Peek().Value || card.Value > ListOrderedStacks[3].Peek().Value)
                 {
                     playableCard.Add(card);
                 }
             });
-
-            return playableCard;
         }
 
         protected override bool testEndGame(List<Card> playableCard)
@@ -146,7 +143,7 @@ namespace TheGameExtreme.model.manager
 
         protected override bool effectLose()
         {
-            foreach (Stack<Card> orderedStack in listOrderedStacks)
+            foreach (Stack<Card> orderedStack in ListOrderedStacks)
             {
                 if (orderedStack.Peek().GetType() == typeof(EndGame))
                 {

TheGameExtreme/view/MainPage.xaml

@@ -7,27 +7,71 @@
     mc:Ignorable="d"
     x:Class="TheGameExtreme.MainPage">
     <StackLayout>
-        <!-- Place new controls here -->
+        <StackLayout
+            Orientation="Vertical"
+            Margin="10,20,10,20">
+            <Label Text="Selectionner la pile sur laquel vous souhaitez poser la carte:" />
+            <StackLayout
+                Orientation="Horizontal"
+                Margin="0,0,0,40">
+                <StackLayout
+                    Orientation="Vertical">
+                    <Label HorizontalTextAlignment="Center" x:Name="pile0" />
                     <StackLayout
                         Orientation="Horizontal">
-            <Label x:Name="pile0" />
+                        <CheckBox x:Name="checkbox0" />
-            <Label x:Name="pile1" />
+                        <Label VerticalTextAlignment="Center" Text="Pile Ascendante" />
-            <Label x:Name="pile2" />
-            <Label x:Name="pile3" />
                     </StackLayout>
-        <ScrollView
+                </StackLayout>
+                <StackLayout
+                    Orientation="Vertical">
+                    <Label HorizontalTextAlignment="Center" x:Name="pile1" />
+                    <StackLayout
+                        Orientation="Horizontal">
+                        <CheckBox x:Name="checkbox1" />
+                        <Label VerticalTextAlignment="Center" Text="Pile Ascendante" />
+                    </StackLayout>
+                </StackLayout>
+                <StackLayout
+                    Orientation="Vertical">
+                    <Label HorizontalTextAlignment="Center" x:Name="pile2" />
+                    <StackLayout
                         Orientation="Horizontal">
+                        <CheckBox x:Name="checkbox2" />
+                        <Label VerticalTextAlignment="Center" Text="Pile Descendante" />
+                    </StackLayout>
+                </StackLayout>
+                <StackLayout
+                    Orientation="Vertical">
+                    <Label HorizontalTextAlignment="Center" x:Name="pile3" />
+                    <StackLayout
+                        Orientation="Horizontal">
+                        <CheckBox x:Name="checkbox3" />
+                        <Label VerticalTextAlignment="Center" Text="Pile Descendante" />
+                    </StackLayout>
+                </StackLayout>
+            </StackLayout>
+            <Label Text="Veuillez selectionner une carte à placer:" />
+            <ScrollView
+                Orientation="Horizontal"
+                Padding="0,5,0,5">
                 <StackLayout
                     Orientation="Horizontal">
-                <Button CommandParameter="card1" x:Name="card1" Clicked="played" />
+                    <Button x:Name="card1" Clicked="played" />
-                <Button CommandParameter="card2" x:Name="card2" Clicked="played" />
+                    <Button x:Name="card2" Clicked="played" />
-                <Button CommandParameter="card3" x:Name="card3" Clicked="played" />
+                    <Button x:Name="card3" Clicked="played" />
-                <Button CommandParameter="card4" x:Name="card4" Clicked="played" />
+                    <Button x:Name="card4" Clicked="played" />
-                <Button CommandParameter="card5" x:Name="card5" Clicked="played" />
+                    <Button x:Name="card5" Clicked="played" />
-                <Button CommandParameter="card6" x:Name="card6" Clicked="played" />
+                    <Button x:Name="card6" Clicked="played" />
-                <Button CommandParameter="card7" x:Name="card7" Clicked="played" />
+                    <Button x:Name="card7" Clicked="played" />
                 </StackLayout>
             </ScrollView>
+        </StackLayout>
+        <StackLayout
+            Orientation="Vertical"
+            Margin="20">
             <Button Text="End Turn" Clicked="endTurn"/>
+            <Label x:Name="Alert" />
+        </StackLayout>
     </StackLayout>
 </ContentPage>

TheGameExtreme/view/MainPage.xaml.cs

@@ -19,28 +19,72 @@ namespace TheGameExtreme
     public partial class MainPage : ContentPage
     {
 
-        private Main viewmodel = new Main();
+        private Main viewmodel;
 
         public MainPage()
         {
             InitializeComponent();
 
-            pile0.SetBinding(Label.TextProperty, new Binding("Stack0", source: viewmodel));
+            viewmodel = new Main(Alert);
-            pile1.SetBinding(Label.TextProperty, new Binding("Stack1", source: viewmodel));
+
-            pile2.SetBinding(Label.TextProperty, new Binding("Stack2", source: viewmodel));
+            viewmodel.BindingChanged += OnBindingChanged;
-            pile3.SetBinding(Label.TextProperty, new Binding("Stack3", source: viewmodel));
+
-            card1.SetBinding(Button.TextProperty, new Binding("ValueCard1", source: viewmodel));
+            //pile0.SetBinding(Label.TextProperty, new Binding("Stack0", source: viewmodel));
-            card2.SetBinding(Button.TextProperty, new Binding("ValueCard2", source: viewmodel));
+            //pile1.SetBinding(Label.TextProperty, new Binding("Stack1", source: viewmodel));
-            card3.SetBinding(Button.TextProperty, new Binding("ValueCard3", source: viewmodel));
+            //pile2.SetBinding(Label.TextProperty, new Binding("Stack2", source: viewmodel));
-            card4.SetBinding(Button.TextProperty, new Binding("ValueCard4", source: viewmodel));
+            //pile3.SetBinding(Label.TextProperty, new Binding("Stack3", source: viewmodel));
-            card5.SetBinding(Button.TextProperty, new Binding("ValueCard5", source: viewmodel));
+            //card1.SetBinding(Button.TextProperty, new Binding("ValueCard1", source: viewmodel));
-            card6.SetBinding(Button.TextProperty, new Binding("ValueCard6", source: viewmodel));
+            //card2.SetBinding(Button.TextProperty, new Binding("ValueCard2", source: viewmodel));
-            card7.SetBinding(Button.TextProperty, new Binding("ValueCard7", source: viewmodel));
+            //card3.SetBinding(Button.TextProperty, new Binding("ValueCard3", source: viewmodel));
+            //card4.SetBinding(Button.TextProperty, new Binding("ValueCard4", source: viewmodel));
+            //card5.SetBinding(Button.TextProperty, new Binding("ValueCard5", source: viewmodel));
+            //card6.SetBinding(Button.TextProperty, new Binding("ValueCard6", source: viewmodel));
+            //card7.SetBinding(Button.TextProperty, new Binding("ValueCard7", source: viewmodel));
+        }
+
+        private void OnBindingChanged(object sender, TopRangeChangedEventArgs args)
+        {
+            switch (args.NumStackChanged)
+            {
+                case 0:
+                    pile0.SetBinding(Label.TextProperty, new Binding("ListOrderedStacks[0].Peek().Value", source: viewmodel));
+                    break;
+                case 1:
+                    pile1.SetBinding(Label.TextProperty, new Binding("ListOrderedStacks[1].Peek().Value", source: viewmodel));
+                    break;
+                case 2:
+                    pile2.SetBinding(Label.TextProperty, new Binding("ListOrderedStacks[2].Peek().Value", source: viewmodel));
+                    break;
+                case 3:
+                    pile3.SetBinding(Label.TextProperty, new Binding("ListOrderedStacks[3].Peek().Value", source: viewmodel));
+                    break;
+            }
         }
 
         private void played(object sender, EventArgs args)
         {
-            viewmodel.played((sender as Button).CommandParameter as string);
+            int numStack;
+            if (checkbox0.IsChecked)
+            {
+                numStack = 0;
+            }
+            else if (checkbox1.IsChecked)
+            {
+                numStack = 1;
+            }
+            else if (checkbox2.IsChecked)
+            {
+                numStack = 2;
+            }
+            else if (checkbox3.IsChecked)
+            {
+                numStack = 3;
+            }
+            else
+            {
+                throw new Exception();
+            }
+            viewmodel.played(numStack, Convert.ToInt32((sender as Button).Text));
         }
 
         private void endTurn(object sender, EventArgs args)

TheGameExtreme/viewmodel/Main.cs

@@ -10,159 +10,75 @@ namespace TheGameExtreme.viewmodel
 {
     public class Main : INotifyPropertyChanged
     {
-        private List<Player> players;
+        Label alert;
         private GameManager gameManager;
-        private int currentIndexPlayer;
+        public List<Card> CurrentHand { get; set; }
-
+        public List<Stack<Card>> listOrderedStacks;
-        public event PropertyChangedEventHandler PropertyChanged;
+        public List<Stack<Card>> ListOrderedStacks
-        private string stack0;
-        public String Stack0
-        {
-            get { return stack0; }
-            set
-            {
-                stack0 = value;
-                OnPropertyChanged("Stack0");
-            }
-        }
-        public string stack1;
-        public String Stack1
-        {
-            get { return stack1; }
-            set
-            {
-                stack1 = value;
-                OnPropertyChanged("Stack1");
-            }
-        }
-        public string stack2;
-        public String Stack2
-        {
-            get { return stack2; }
-            set
-            {
-                stack2 = value;
-                OnPropertyChanged("Stack2");
-            }
-        }
-        public string stack3;
-        public String Stack3
-        {
-            get { return stack3; }
-            set
         {
-                stack3 = value;
+            get { return listOrderedStacks; }
-                OnPropertyChanged("Stack3");
-            }
-        }
-        private int valueCard1;
-        public int ValueCard1
-        {
-            get { return valueCard1; }
             set
             {
-                valueCard1 = value;
+                listOrderedStacks = value;
-                OnPropertyChanged("ValueCard1");
+                OnPropertyChanged("Stack change");
             }
         }
-        private void OnPropertyChanged(string v)
+        private void OnPropertyChanged(string info)
         {
-            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(v));
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(info));
         }
 
+        public event EventHandler<TopRangeChangedEventArgs> BindingChanged;
+        public event PropertyChangedEventHandler PropertyChanged;
 
-        public Main()
+        public Main(Label alert)
         {
-            stack0 = "1";
+            this.alert = alert;
-            stack1 = "1";
-            stack2 = "100";
-            stack3 = "100";
 
-            players = new List<Player> { new Player("Clément"), new Player("Baptiste") };
+            gameManager = new SoloGameManager(2, new List<String> { "Clément", "Baptiste" }) ;  // Donner le nom des joueurs
-
-            gameManager = new SoloGameManager(2, players);
 
             gameManager.TopRangeChanged += OnTopRangeChanged;
-            players.ForEach(player =>
-            {
-                player.HandCardChanged += OnHandCardChanged;
-            });
-            gameManager.CurrentPlayerChanged += OnCurrentPlayerChanged;
 
-            valueCard1 = players[currentIndexPlayer].getCardList()[0].Value;
+            gameManager.PlayerChanged += OnPlayerChanged;
-        }
 
-        public void OnTopRangeChanged(object source, TopRangeChangedEventArgs args)
+            CurrentHand = gameManager.CurrentHand;
-        {
+
-            switch (args.NumStackChanged)
+            ListOrderedStacks = gameManager.ListOrderedStacks;
-            {
-                case 0:
-                    stack0 = args.NewTopRangeCard.Value.ToString();
-                    break;
-                case 1:
-                    Stack1 = args.NewTopRangeCard.Value.ToString();
-                    break;
-                case 2:
-                    Stack2 = args.NewTopRangeCard.Value.ToString();
-                    break;
-                case 3:
-                    Stack3 = args.NewTopRangeCard.Value.ToString();
-                    break;
-            }
         }
 
-        private void OnHandCardChanged(object source, HandCardChangedEventArgs args) // Double les appels car les joueurs sont les mêmes dans le model et ici
+        protected internal void OnPlayerChanged(object source, PlayerChangedEventArgs args)
-        {
-            players[currentIndexPlayer].getCardList().ForEach(card =>
         {
-
+            CurrentHand = args.NewCurrentHand;
-            });
-            valueCard1 = players[currentIndexPlayer].getCardList()[0].Value;
         }
 
-        private void OnCurrentPlayerChanged(object source, CurrentPlayerChangedEventArgs args)
+        public void OnTopRangeChanged(object source, TopRangeChangedEventArgs args)
         {
-            currentIndexPlayer = args.NewCurrentPlayer;
+            BindingChanged?.Invoke(this, args);
         }
 
-        public void played(string text)
+        public void played(int numStack, int valueCard)
         {
-            if (players[currentIndexPlayer].getCardList().Count != 0)
+            if (gameManager.isCanPlay())
             {
-                int r = new Random().Next(0, 3);
+                playOneCard(numStack, valueCard);
-                playOneCard(text, r);
             }
             else
             {
-                // Throw Exception
+                alert.Text = "Le joueur n'a plus de carte dans sa main!";
+                // Faire un toast
             }
         }
 
-        private void playOneCard(string text, int r)
+        private void playOneCard(int numStack, int valueCard)
         {
-            switch (text)
+            try
+            {
+                gameManager.joue(valueCard, numStack);
+            }
+            catch(Exception e)
             {
-                case "card1":
+                // Faire un toast
-                    gameManager.joue(players[currentIndexPlayer].getCardList()[0], r);
+                alert.Text = e.Message;
-                    break;
-                case "card2":
-                    gameManager.joue(players[currentIndexPlayer].getCardList()[1], r);
-                    break;
-                case "card3":
-                    gameManager.joue(players[currentIndexPlayer].getCardList()[2], r);
-                    break;
-                case "card4":
-                    gameManager.joue(players[currentIndexPlayer].getCardList()[3], r);
-                    break;
-                case "card5":
-                    gameManager.joue(players[currentIndexPlayer].getCardList()[4], r);
-                    break;
-                case "card6":
-                    gameManager.joue(players[currentIndexPlayer].getCardList()[5], r);
-                    break;
-                case "card7":
-                    gameManager.joue(players[currentIndexPlayer].getCardList()[6], r);
-                    break;
             }
         }