Merge branch 'reconstruction_model' - Version Semi-Stable (encore légèrement brouillon par manque de temps)

TheGameExtreme/Preparateur.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using TheGameExtreme.model;
+using TheGameExtreme.model.gameActions.classic;
+
+namespace TheGameExtreme
+{
+    public class Parametreur
+    {
+
+        public GameMode GameMode { get; set; }
+        public List<Player> players = new List<Player>();
+        public int NbPlayer { get; set; }
+
+        public Parametreur(GameMode gameMode)
+        {
+            GameMode = gameMode;
+        }
+
+        public void Prepare()
+        {
+            NbPlayer = players.Count;
+            GameMode.load(NbPlayer, players);
+        }
+
+        public void AddPlayer(Player player)
+        {
+            if (player != null)
+            {
+                players.Add(player);
+            }
+        }
+    }
+}

TheGameExtreme/TheGameExtreme.csproj

@@ -14,11 +14,10 @@
     <Folder Include="viewmodel\" />
     <Folder Include="model\card\" />
     <Folder Include="model\deck\" />
-    <Folder Include="model\rule\" />
-    <Folder Include="model\rule\playRules\" />
     <Folder Include="model\Card\rapidCard\" />
-    <Folder Include="model\rule\endTurnRules\" />
-    <Folder Include="model\rule\beforeEndTurnRules\" />
+    <Folder Include="model\gameActions\" />
+    <Folder Include="model\gameActions\extreme\" />
+    <Folder Include="model\gameActions\classic\" />
   </ItemGroup>
   <ItemGroup>
     <Compile Remove="model\effect\StopColm.cs" />

TheGameExtreme/model/Card/Card.cs

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

TheGameExtreme/model/GameMode.cs

@@ -1,92 +0,0 @@
-using System;
-using System.Collections.Generic;
-using TheGameExtreme.model.card;
-using TheGameExtreme.model.rule;
-using TheGameExtreme.model.rule.beforeEndTurnRules;
-using TheGameExtreme.model.rule.endTurnRules;
-using TheGameExtreme.model.rule.playRules;
-
-namespace TheGameExtreme.model
-{
-    public class GameMode
-    {
-
-        private List<Rule> playRule = new List<Rule>();
-        private List<Rule> beforeEndTurnRule = new List<Rule>();
-        private List<Rule> endTurnRule = new List<Rule>();
-        private List<Rule> commonRule = new List<Rule>();
-
-        public GameMode()
-        {
-        }
-
-        public void addPlayRule(PlayRule rule)
-        {
-            playRule?.Add(rule);
-        }
-
-        public void addEndTurnRule(EndTurnRule rule)
-        {
-            endTurnRule?.Add(rule);
-        }
-
-        public void addBeforeEndTurnRule(BeforeEndTurnRule rule)
-        {
-            beforeEndTurnRule?.Add(rule);
-        }
-
-        public void addCommonRule(Rule rule)
-        {
-            // Vérifier que se ne soit ni une PlayRule, ni une EndTurnRule ?
-            commonRule?.Add(rule);
-        }
-
-        public bool checkPlayRule(Card card, Stack<Card> orderedStack, bool bottomUp, List<Card> CurrentHand)
-        {
-            foreach(PlayRule rule in playRule)
-            {
-                if (rule.Test(card, orderedStack, bottomUp, CurrentHand))    // Gestion des messages pour savoir qu'elle règle n'est pas respecter.
-                {
-                    return true;
-                }
-            }
-            foreach (Rule rule in commonRule)
-            {
-
-            }
-            return false;
-        }
-
-        public bool checkBeforeEndTurnRule(List<Card> CurrentCardPlayed, int nbCardAtBeginOfTurn, List<Card> CurrentHand)
-        {
-            foreach (BeforeEndTurnRule rule in beforeEndTurnRule)
-            {
-                if (!rule.Test(CurrentCardPlayed, nbCardAtBeginOfTurn, CurrentHand))    // Gestion des messages pour savoir qu'elle règle n'est pas respecter.
-                {
-                    return false;
-                }
-            }
-            foreach (Rule rule in commonRule)
-            {
-
-            }
-            return true;
-        }
-
-        public bool checkEndTurnRule(List<Card> CurrentCardPlayed, int nbCardAtBeginOfTurn, List<Card> CurrentHand)
-        {
-            foreach (EndTurnRule rule in endTurnRule)
-            {
-                if (!rule.Test(CurrentCardPlayed, nbCardAtBeginOfTurn, CurrentHand))    // Gestion des messages pour savoir qu'elle règle n'est pas respecter.
-                {
-                    return false;
-                }
-            }
-            foreach (Rule rule in commonRule)
-            {
-
-            }
-            return true;
-        }
-    }
-}

TheGameExtreme/model/deck/Deck.cs

@@ -9,11 +9,6 @@ namespace TheGameExtreme.model
 
         protected List<Card> deck = new List<Card>();
 
-        public Deck()
-        {
-
-        }
-
         public int size()
         {
             return deck.Count;

TheGameExtreme/model/gameActions/GameAction.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using TheGameExtreme.model.card;
+
+namespace TheGameExtreme.model.gameActions
+{
+    public abstract class GameAction
+    {
+        protected Piles ListOrderedStacks { get; set; }
+        public String ErrorMessage { get; set; }
+
+        protected GameAction(Piles listOrderedStacks)
+        {
+            ListOrderedStacks = listOrderedStacks;
+        }
+    }
+}

TheGameExtreme/model/gameActions/Piles.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using TheGameExtreme.model.card;
+
+namespace TheGameExtreme.model.gameActions
+{
+    public class Piles
+    {
+
+        private List<Stack<Card>> ListOrderedStacks { get; set; }
+
+        public Piles()
+        {
+            ListOrderedStacks = new List<Stack<Card>>();
+
+            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++)
+            {
+                if (i < 2)
+                {
+                    ListOrderedStacks[i].Push(new ClassicCard(1));
+                }
+                else
+                {
+                    ListOrderedStacks[i].Push(new ClassicCard(100));
+                }
+            }
+        }
+
+        public Stack<Card> getStack(int i)
+        {
+            return ListOrderedStacks[i];
+        }
+    }
+}

TheGameExtreme/model/gameActions/classic/GameMode.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Generic;
+using TheGameExtreme.model.card;
+using TheGameExtreme.model.deck;
+using TheGameExtreme.model.@event;
+using TheGameExtreme.model.gameActions;
+
+namespace TheGameExtreme.model.gameActions.classic
+{
+    public class GameMode
+    {
+
+        protected List<GameAction> gameActions;
+        protected Piles piles;
+        protected int nbCardAtBeginOfTurn = 7;
+        protected Deck deck;
+        private int nbMaxCard;
+        public String Message { get; set; }
+
+
+        #region
+
+        public event EventHandler<TopRangeChangedEventArgs> TopRangeChanged;
+        public event EventHandler<PlayerChangedEventArgs> PlayerChanged;
+        protected internal void OnTopRangeChanged(TopRangeChangedEventArgs args)
+        {
+            TopRangeChanged?.Invoke(this, args);
+        }
+        protected internal void OnPlayerChanged(PlayerChangedEventArgs args)
+        {
+            PlayerChanged?.Invoke(this, args);
+        }
+
+        #endregion
+
+
+        public GameMode()
+        {
+            gameActions = new List<GameAction>();
+        }
+
+        public void load(int nbPlayer, List<Player> players)
+        {
+            piles = new Piles();
+
+            gameActions.Add(new Piocher(piles));
+            gameActions.Add(new JouerUneCarte(piles));
+            gameActions.Add(new TerminerSonTour(piles));
+
+            createDeck();
+            defineNbMaxCard(nbPlayer);
+            distribueCard(players);
+        }
+
+        protected void createDeck()
+        {
+            switch (true)
+            {
+                case false:
+                    deck = new ClassicDeck();
+                    break;
+
+                default:
+                    deck = new ExtremeDeck();
+                    break;
+            }
+        }
+
+        protected void defineNbMaxCard(int nbPlayer)
+        {
+            switch (nbPlayer)
+            {
+                case 1:
+                    nbMaxCard = 8;
+                    break;
+                case 2:
+                    nbMaxCard = 7;
+                    break;
+                default:
+                    nbMaxCard = 6;
+                    break;
+            }
+        }
+
+        protected void distribueCard(List<Player> players)
+        {
+            for (int i = 0; i < nbMaxCard; i++)
+            {
+                players.ForEach(player =>
+                {
+                    int r = new Random().Next(0, deck.size() - 1);
+                    player.pioche(deck.getCard(r));
+                    deck.removeAt(r);
+                });
+            }
+        }
+
+        public void pioche(List<Card> currentHand, Player player)
+        {
+            Message = null;
+            ((Piocher)gameActions[0]).pioche(currentHand, deck, player);
+        }
+
+        public void playCard(int valueCard, List<Card> currentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed)
+        {
+            Message = null;
+            if (((JouerUneCarte)gameActions[1]).play(valueCard, currentHand, orderedStackSelected, player, CurrentCardPlayed))
+            {
+                OnTopRangeChanged(new TopRangeChangedEventArgs(piles.getStack(orderedStackSelected).Peek(), ((JouerUneCarte)gameActions[1]).OldCard, orderedStackSelected));
+            }
+            else
+            {
+                Message = ((JouerUneCarte)gameActions[1]).ErrorMessage;
+            }
+        }
+
+        public bool endTurn(List<Card> currentHand, List<Card> CurrentCardPlayed, Player player)
+        {
+            Message = null;
+            if (((TerminerSonTour)gameActions[2]).end(currentHand, nbCardAtBeginOfTurn, CurrentCardPlayed))
+            {
+                pioche(currentHand, player);
+                nbCardAtBeginOfTurn = currentHand.Count;
+                CurrentCardPlayed.Clear();
+                
+                OnPlayerChanged(null);
+                return false;
+            }
+            else
+            {
+                Message = ((TerminerSonTour)gameActions[2]).ErrorMessage;
+                return true;
+            }
+        }
+
+        #region Decaler dans un GameAction
+
+        public bool isEndGame(List<Card> currentHand)
+        {
+            if (currentHand.Count != 0)
+            {
+                List<Card> playableCard = new List<Card>();
+                tryToFindSoluce(playableCard, currentHand);
+                return testEndGame(playableCard);
+            }
+            return false;
+        }
+
+        protected void tryToFindSoluce(List<Card> playableCard, List<Card> currentHand)
+        {
+            currentHand.ForEach(card =>
+            {
+                if (card.Value > piles.getStack(0).Peek().Value || card.Value > piles.getStack(1).Peek().Value || card.Value < piles.getStack(2).Peek().Value || card.Value < piles.getStack(3).Peek().Value)
+                {
+                    playableCard.Add(card);
+                }
+            });
+        }
+
+        protected bool testEndGame(List<Card> playableCard)
+        {
+            if (playableCard.Count < 2)
+            {
+                Message = "Le jeu est terminé!\n Désolé, vous avez perdu... Essayez encore!";
+                return true;
+            }
+
+            return false;
+        }
+
+        #endregion
+    }
+}

TheGameExtreme/model/gameActions/classic/JouerUneCarte.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using TheGameExtreme.model.card;
+
+namespace TheGameExtreme.model.gameActions.classic
+{
+    public class JouerUneCarte : GameAction
+    {
+
+        public Card OldCard { get; set; }
+
+
+        public JouerUneCarte(Piles ListOrderedStacks) : base(ListOrderedStacks)
+        {
+        }
+
+        public bool play(int valueCard, List<Card> CurrentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed)
+        {
+            foreach (Card card in CurrentHand)
+            {
+                if (valueCard == card.Value)
+                {
+                    if (orderedStackSelected >= 0 && orderedStackSelected < 4)
+                    {
+                        if (orderedStackSelected < 2)
+                        {
+                            ErrorMessage = null;
+                            return rule(card, ListOrderedStacks.getStack(orderedStackSelected), true, player, CurrentCardPlayed);
+                        }
+                        else
+                        {
+                            ErrorMessage = null;
+                            return rule(card, ListOrderedStacks.getStack(orderedStackSelected), false, player, CurrentCardPlayed);
+                        }
+                    }
+                    else
+                    {
+                        ErrorMessage = AppRessource.StrCantGetStack;
+                    }
+                }
+            }
+            return false;
+        }
+
+        private bool rule(Card card, Stack<Card> stack, bool bottomUp, Player player, List<Card> CurrentCardPlayed)
+        {
+            if ((bottomUp && card.Value > stack.Peek().Value) || (!bottomUp && card.Value < stack.Peek().Value) || card.Value == stack.Peek().Value - 10 || card.Value == stack.Peek().Value + 10)
+            {
+                OldCard = stack.Peek();
+                player.joue(card);
+                CurrentCardPlayed.Add(card);
+                stack.Push(card);
+
+                return true;
+                //OnTopRangeChanged(new TopRangeChangedEventArgs(card, oldCard, ListOrderedStacks.IndexOf(orderedStack)));
+            }
+            else
+            {
+                ErrorMessage = AppRessource.StrWrongStack;
+                return false;
+            }
+        }
+    }
+}

TheGameExtreme/model/gameActions/classic/Piocher.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using TheGameExtreme.model.card;
+
+namespace TheGameExtreme.model.gameActions.classic
+{
+    public class Piocher : GameAction
+    {
+
+        protected int nbMaxCard = 7; // Changer
+
+        public Piocher(Piles ListOrderedStacks) : base(ListOrderedStacks)
+        {
+        }
+
+        protected bool checkRule()
+        {
+            return true;
+        }
+
+        public void pioche(List<Card> CurrentHand, Deck deck, Player player)
+        {
+            int nbPickedCard = nbMaxCard - CurrentHand.Count;
+            for (int i = 0; i < nbPickedCard; i++)
+            {
+                if (deck.size() == 0)
+                {
+                    return;
+                }
+                int random = new Random().Next(0, deck.size() - 1);
+                player.pioche(deck.getCard(random));
+                deck.removeAt(random);
+            }
+        }
+    }
+}

TheGameExtreme/model/gameActions/classic/TerminerSonTour.cs

@@ -3,21 +3,33 @@ using System.Collections.Generic;
 using TheGameExtreme.model.card;
 using TheGameExtreme.model.card.rapidCard;
 
-namespace TheGameExtreme.model.rule.endTurnRules
+namespace TheGameExtreme.model.gameActions.classic
 {
-    public class EndGame : EndTurnRule
+    public class TerminerSonTour : GameAction
     {
 
-        public static readonly String REGLE_ENDGAME = "End Game";
 
-        public List<Stack<Card>> ListOrderedStacks { get; set; }
+        public TerminerSonTour(Piles ListOrderedStacks) : base(ListOrderedStacks)
+        {
+        }
 
-        public EndGame(List<Stack<Card>> ListOrderedStacks)
+        public bool end(List<Card> CurrentHand, int nbCardAtBeginOfTurn, List<Card> CurrentCardPlayed)
+        {
+            // Si carte qui fait piocher que d'un, vérifier la bonne pioche (penser si elle vient d'être recouverte)
+            // Sinon
+            if (nbCardAtBeginOfTurn == CurrentCardPlayed.Count || CurrentHand.Count == 0 || CurrentCardPlayed.Count >= 2)
+            {   // Ne pas oublié de gérer les ThreeCard
+                return Test(CurrentHand);
+            }
+            else
             {
-            this.ListOrderedStacks = ListOrderedStacks;
+                ErrorMessage = AppRessource.StrCardPlayedLessThanTwo;
+                return false;
+            }
+            
         }
 
-        public override bool Test(List<Card> CurrentCardPlayed, int nbCardAtBeginOfTurn, List<Card> CurrentHand)
+        public bool Test(List<Card> CurrentHand)
         {
             if (CurrentHand.Count != 0)
             {
@@ -32,7 +44,7 @@ namespace TheGameExtreme.model.rule.endTurnRules
         {
             CurrentHand.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.getStack(0).Peek().Value || card.Value > ListOrderedStacks.getStack(1).Peek().Value || card.Value < ListOrderedStacks.getStack(2).Peek().Value || card.Value < ListOrderedStacks.getStack(3).Peek().Value)
                 {
                     playableCard.Add(card);
                 }
@@ -57,6 +69,5 @@ namespace TheGameExtreme.model.rule.endTurnRules
             }
             return true;
         }
-
     }
 }

TheGameExtreme/model/gameActions/extreme/ExtremeJouerUneCarte.cs

@@ -0,0 +1,12 @@
+using System;
+using TheGameExtreme.model.gameActions.classic;
+
+namespace TheGameExtreme.model.gameActions.extreme
+{
+    public class ExtremeJouerUneCarte : JouerUneCarte
+    {
+        public ExtremeJouerUneCarte(Piles ListOrderedStacks) : base(ListOrderedStacks)
+        {
+        }
+    }
+}

TheGameExtreme/model/gameActions/extreme/ExtremeMode.cs

@@ -0,0 +1,15 @@
+using System;
+using TheGameExtreme.model.gameActions.classic;
+
+namespace TheGameExtreme.model.gameActions.extreme
+{
+    public class ExtremeMode : GameMode
+    {
+        public ExtremeMode()
+        {
+            gameActions.Add(new ExtremePiocher(piles));
+            gameActions.Add(new ExtremeJouerUneCarte(piles));
+            gameActions.Add(new ExtremeTerminerSonTour(piles));
+        }
+    }
+}

TheGameExtreme/model/gameActions/extreme/ExtremePiocher.cs

@@ -0,0 +1,12 @@
+using System;
+using TheGameExtreme.model.gameActions.classic;
+
+namespace TheGameExtreme.model.gameActions.extreme
+{
+    public class ExtremePiocher : Piocher
+    {
+        public ExtremePiocher(Piles ListOrderedStacks) : base(ListOrderedStacks)
+        {
+        }
+    }
+}

TheGameExtreme/model/gameActions/extreme/ExtremeTerminerSonTour.cs

@@ -0,0 +1,12 @@
+using System;
+using TheGameExtreme.model.gameActions.classic;
+
+namespace TheGameExtreme.model.gameActions.extreme
+{
+    public class ExtremeTerminerSonTour : TerminerSonTour
+    {
+        public ExtremeTerminerSonTour(Piles ListOrderedStacks) : base(ListOrderedStacks)
+        {
+        }
+    }
+}

TheGameExtreme/model/manager/GameManager.cs

@@ -1,234 +1,293 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using TheGameExtreme.model.card;
-using TheGameExtreme.model.deck;
 using TheGameExtreme.model.@event;
-using TheGameExtreme.model.rule.beforeEndTurnRules;
-using TheGameExtreme.model.rule.endTurnRules;
-using TheGameExtreme.model.rule.playRules;
+using TheGameExtreme.model.gameActions;
+using TheGameExtreme.model.gameActions.classic;
 
 namespace TheGameExtreme.model.manager
 {
-    public abstract class GameManager
+    public abstract class GameManager: INotifyPropertyChanged
     {
 
-        public readonly int nbPlayer;
-        protected int nbMaxCard;
-        protected int currentIndexPlayer;
-        protected List<Player> playerList = new List<Player>();
-        public List<Stack<Card>> ListOrderedStacks { get; set; }
-        protected Deck deck;
-        protected bool win = true;
-        public String EndMessage { get; set; }
-        public event EventHandler<TopRangeChangedEventArgs> TopRangeChanged;
-        public event EventHandler<PlayerChangedEventArgs> PlayerChanged;
-        public List<Card> CurrentHand { get; set; }
-        protected int nbCardAtBeginOfTurn;
-        protected List<Card> CurrentCardPlayed = new List<Card>();
-        protected string langue;
+        /* GameMaster implémente un mode de jeu (classe fille de gameMode qui connait les actions a effectué en fonction du mode de jeu */
 
-        protected GameMode gameMode;
+        protected Parametreur preparateur;
+        public Piles ListOrderedStacks { get; set; }
+        protected List<Card> CurrentCardPlayed = new List<Card>();
+        public String EndMessage { get; set; }
+        protected int currentIndexPlayer;
 
 
-        protected GameManager(int nbPlayer, List<String> players)
+        protected List<Card> currentHand;
+        public List<Card> CurrentHand
         {
-            ListOrderedStacks = new List<Stack<Card>>();
-            CurrentHand = new List<Card>();
-
-            this.nbPlayer = nbPlayer;
-            players.ForEach(player => playerList.Add(new Player(player)));
-
-
-            initStacks();
-
-            initRule();
-
-            createDeck();
-            defineNbMaxCard();
-            distribueCard();
-
-            CurrentHand = playerList[currentIndexPlayer].getCardList();
-            nbCardAtBeginOfTurn = CurrentHand.Count;
+            get { return currentHand; }
+            set
+            {
+                currentHand = value;
+                OnPropertyChanged("CurrentHand");
+            }
         }
 
-        protected void initStacks()
-        {
-            ListOrderedStacks.Add(new Stack<Card>());
-            ListOrderedStacks.Add(new Stack<Card>());
-            ListOrderedStacks.Add(new Stack<Card>());
-            ListOrderedStacks.Add(new Stack<Card>());
+        #region event
 
-            for (int i = 0; i < 4; i++)
-            {
-                if (i < 2)
+        public event EventHandler<TopRangeChangedEventArgs> TopRangeChanged;
+        public event EventHandler<PlayerChangedEventArgs> PlayerChanged;
+        public event PropertyChangedEventHandler PropertyChanged;
+        public virtual void OnPropertyChanged(string info)
         {
-                    ListOrderedStacks[i].Push(new ClassicCard(1));
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(info));
         }
-                else
+        public void OnTopRangeChanged(object source, TopRangeChangedEventArgs args)
         {
-                    ListOrderedStacks[i].Push(new ClassicCard(100));
+            TopRangeChanged?.Invoke(this, args);
         }
+        protected internal void OnPlayerChanged(object source, PlayerChangedEventArgs args)
+        {
+            currentIndexPlayer += 1;
+            if (currentIndexPlayer == preparateur.players.Count)
+            {
+                currentIndexPlayer = 0;
             }
+            CurrentHand = preparateur.players[currentIndexPlayer].getCardList();
+            PlayerChanged?.Invoke(this, new PlayerChangedEventArgs(CurrentHand, preparateur.players[currentIndexPlayer].Pseudo));
         }
 
-        protected void initRule()
-        {
-            gameMode = new GameMode();
-            gameMode.addPlayRule(new Ascendant());
-            gameMode.addPlayRule(new Descendant());
-            gameMode.addPlayRule(new PasDeDix());
-            //gameMode.addPlayRule(new VoidHand());
-            gameMode.addBeforeEndTurnRule(new NbCardPlay());
-            gameMode.addEndTurnRule(new EndGame(ListOrderedStacks));
-            //gameMode.addEndTurnRule(new VoidDeck());
-            //gameMode.addEndTurnRule(new CompleteHand());
-        }
+        #endregion
 
-        protected void createDeck()
-        {
-            switch (true)
-            {
-                case false:
-                    deck = new ClassicDeck();
-                    break;
 
-                default:
-                    deck = new ExtremeDeck();
-                    break;
-            }
-        }
 
-        protected void defineNbMaxCard()
+        protected GameManager(Parametreur parametreur)
         {
-            switch (nbPlayer)
-            {
-                case 1:
-                    nbMaxCard = 8;
-                    break;
-                case 2:
-                    nbMaxCard = 7;
-                    break;
-                default:
-                    nbMaxCard = 6;
-                    break;
-            }
-        }
+            this.preparateur = parametreur;
 
-        protected void distribueCard()
-        {
-            for (int i = 0; i < nbMaxCard; i++)
-            {
-                playerList.ForEach(player => {
-                    int r = new Random().Next(0, deck.size() - 1);
-                    player.pioche(deck.getCard(r));
-                    deck.removeAt(r);
-                });
-            }
+            parametreur.Prepare();
+
+            parametreur.GameMode.TopRangeChanged += OnTopRangeChanged;
+
+            parametreur.GameMode.PlayerChanged += OnPlayerChanged;
+
+            CurrentHand = parametreur.players[0].getCardList();
         }
 
+        
+
         public void joue(int valueCard, int orderedStackSelected)
         {
-            if (EndMessage != null)
-            {
-                //throw new Exception("Le jeu est fini! Veuillez lancer une nouvelle partie!");
-                throw new Exception(AppRessource.StrEndOfGame);
+            preparateur.GameMode.playCard(valueCard, currentHand, orderedStackSelected, preparateur.players[currentIndexPlayer], CurrentCardPlayed); // Mettre le joueur actif
+            EndMessage = preparateur.GameMode.Message;
         }
-            foreach(Card card in CurrentHand)
-            {
-                if (valueCard == card.Value)
+
+        public bool endTurn()
         {
-                    if (orderedStackSelected >= 0 && orderedStackSelected < 4)
+            if(preparateur.GameMode.endTurn(currentHand, CurrentCardPlayed, preparateur.players[currentIndexPlayer]))
             {
-                        if (orderedStackSelected < 2)
+                EndMessage = preparateur.GameMode.Message;
+                if (isEndGame())
                 {
-                            testPossibility(card, ListOrderedStacks[orderedStackSelected], true);
+                    EndMessage = preparateur.GameMode.Message;
+                    return true;
                 }
                 else
                 {
-                            testPossibility(card, ListOrderedStacks[orderedStackSelected], false);
+                    return false;
                 }
             }
             else
             {
-                        throw new Exception(AppRessource.StrCantGetStack);
-                    }
-                    return;
-                }
+                return false;
             }
         }
 
-        protected void testPossibility(Card card, Stack<Card> orderedStack, bool bottomUp)
+        private bool isEndGame()
         {
-            if (gameMode.checkPlayRule(card, orderedStack, bottomUp, CurrentHand))
-            {
-                Card oldCard = orderedStack.Peek();
-                playerList[currentIndexPlayer].joue(card);
-                CurrentCardPlayed.Add(card);
-                orderedStack.Push(card);
-                OnTopRangeChanged(new TopRangeChangedEventArgs(card, oldCard, ListOrderedStacks.IndexOf(orderedStack)));
-                //if (CurrentHand.Count == 0)
+            return preparateur.GameMode.isEndGame(currentHand);
+        }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        //public readonly int nbPlayer;
+        //protected int nbMaxCard;
+        //protected int currentIndexPlayer;
+        //protected List<Player> playerList = new List<Player>();
+        //public List<Stack<Card>> ListOrderedStacks { get; set; }
+        //protected Deck deck;
+        //protected bool win = true;
+        //public String EndMessage { get; set; }
+        //public List<Card> CurrentHand { get; set; }
+        //protected int nbCardAtBeginOfTurn;
+        //protected List<Card> CurrentCardPlayed = new List<Card>();
+        //protected string langue;
+        //public event EventHandler<TopRangeChangedEventArgs> TopRangeChanged;
+        //public event EventHandler<PlayerChangedEventArgs> PlayerChanged;
+
+
+        //protected GameManager(int nbPlayer, List<String> players)
         //{
-                //    endTurn(); // Presque bon, oublie juste d'afficher les nouvelles cartes
+        //    ListOrderedStacks = new List<Stack<Card>>();
+        //    CurrentHand = new List<Card>();
+
+        //    this.nbPlayer = nbPlayer;
+        //    players.ForEach(player => playerList.Add(new Player(player)));
+
+
+        //    initStacks();
+
+        //    initRule();
+
+        //    createDeck();
+        //    defineNbMaxCard();
+        //    distribueCard();
+
+        //    CurrentHand = playerList[currentIndexPlayer].getCardList();
+        //    nbCardAtBeginOfTurn = CurrentHand.Count;
         //}
-            }
-            else
-            {
-                throw new Exception(AppRessource.StrWrongStack);
-            }
 
+        //protected void initStacks()
+        //{
+        //    ListOrderedStacks = new List<Stack<Card>>();
+
+        //    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++)
+        //    {
+        //        if (i < 2)
+        //        {
+        //            ListOrderedStacks[i].Push(new ClassicCard(1));
+        //        }
+        //        else
+        //        {
+        //            ListOrderedStacks[i].Push(new ClassicCard(100));
+        //        }
+        //    }
+        //}
 
-            //if ((bottomUp && card.Value > orderedStack.Peek().Value) || (!bottomUp && card.Value < orderedStack.Peek().Value) || card.Value == orderedStack.Peek().Value + 10 || card.Value == orderedStack.Peek().Value - 10)
+        //protected void createDeck()
         //{
-            //    Card oldCard = orderedStack.Peek();
-            //    playerList[currentIndexPlayer].joue(card);
-            //    CurrentCardPlayed.Add(card);
-            //    orderedStack.Push(card);
-            //    OnTopRangeChanged(new TopRangeChangedEventArgs(card, oldCard, ListOrderedStacks.IndexOf(orderedStack)));
+        //    switch (true)
+        //    {
+        //        case false:
+        //            deck = new ClassicDeck();
+        //            break;
+
+        //        default:
+        //            deck = new ExtremeDeck();
+        //            break;
+        //    }
         //}
-            //else
+
+        //protected void defineNbMaxCard()
         //{
-            //    throw new Exception(AppRessource.StrWrongStack);
+        //    switch (nbPlayer)
+        //    {
+        //        case 1:
+        //            nbMaxCard = 8;
+        //            break;
+        //        case 2:
+        //            nbMaxCard = 7;
+        //            break;
+        //        default:
+        //            nbMaxCard = 6;
+        //            break;
+        //    }
         //}
-        }
 
-        protected internal void OnTopRangeChanged(TopRangeChangedEventArgs args)
-        {
-            TopRangeChanged?.Invoke(this, args);
-        }
+        //protected void distribueCard()
+        //{
+        //    for (int i = 0; i < nbMaxCard; i++)
+        //    {
+        //        players.ForEach(player =>
+        //        {
+        //            int r = new Random().Next(0, deck.size() - 1);
+        //            player.pioche(deck.getCard(r));
+        //            deck.removeAt(r);
+        //        });
+        //    }
+        //}
 
-        protected internal void OnPlayerChanged(PlayerChangedEventArgs args)
-        {
-            PlayerChanged?.Invoke(this, args);
-        }
+        //public void joue(int valueCard, int orderedStackSelected)
+        //{
+        //    gameMode.playCard(valueCard, CurrentHand, orderedStackSelected, players[0], CurrentCardPlayed); // Mettre le joueur actif
+        //}
 
-        public bool isCanPlay()
-        {
-            if (CurrentHand.Count > 0)
-            {
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
+        //protected void testPossibility(Card card, Stack<Card> orderedStack, bool bottomUp)
+        //{
+        //    //if (gameMode.checkPlayRule(card, orderedStack, bottomUp, CurrentHand))
+        //    //{
+        //    //    Card oldCard = orderedStack.Peek();
+        //    //    playerList[currentIndexPlayer].joue(card);
+        //    //    CurrentCardPlayed.Add(card);
+        //    //    orderedStack.Push(card);
+        //    //    OnTopRangeChanged(new TopRangeChangedEventArgs(card, oldCard, ListOrderedStacks.IndexOf(orderedStack)));
+        //    //    //if (CurrentHand.Count == 0)
+        //    //    //{
+        //    //    //    endTurn(); // Presque bon, oublie juste d'afficher les nouvelles cartes
+        //    //    //}
+        //    //}
+        //    //else
+        //    //{
+        //    //    throw new Exception(AppRessource.StrWrongStack);
+        //    //}
+        //}
+
+        //protected internal void OnTopRangeChanged(TopRangeChangedEventArgs args)
+        //{
+        //    TopRangeChanged?.Invoke(this, args);
+        //}
+
+        //protected internal void OnPlayerChanged(PlayerChangedEventArgs args)
+        //{
+        //    PlayerChanged?.Invoke(this, args);
+        //}
 
-        abstract public bool endTurn();
+        //public bool isCanPlay()
+        //{
+        //    if (CurrentHand.Count > 0)
+        //    {
+        //        return true;
+        //    }
+        //    else
+        //    {
+        //        return false;
+        //    }
+        //}
 
-        abstract protected void pioche();
+        //abstract public bool endTurn();
 
-        abstract protected bool isEndGame();
+        //abstract protected bool isEndGame();
 
-        abstract protected void tryToFindSoluce(List<Card> playableCard);
+        //abstract protected void tryToFindSoluce(List<Card> playableCard);
 
-        abstract protected bool testEndGame(List<Card> playableCard);
+        //abstract protected bool testEndGame(List<Card> playableCard);
 
-        abstract protected bool effectLose();
+        //abstract protected bool effectLose();
 
-        public int getCurentIndexPlayer()
-        {
-            return currentIndexPlayer;
-        }
+        //public int getCurentIndexPlayer()
+        //{
+        //    return currentIndexPlayer;
+        //}
 
     }
 }

TheGameExtreme/model/manager/MultiplayerGameManager.cs

@@ -1,11 +1,12 @@
 using System;
 using System.Collections.Generic;
+using TheGameExtreme.model.gameActions.classic;
 
 namespace TheGameExtreme.model.manager
 {
     public abstract class MultiplayerGameManager : GameManager
     {
-        protected MultiplayerGameManager(int nbPlayer, List<string> players) : base(nbPlayer, players)
+        protected MultiplayerGameManager(Parametreur parametreur) : base(parametreur)
         {
         }
     }

TheGameExtreme/model/manager/SoloGameManager.cs

@@ -1,177 +1,175 @@
 using System;
 using System.Collections.Generic;
-using TheGameExtreme.model.card;
-using TheGameExtreme.model.card.rapidCard;
-using TheGameExtreme.model.@event;
+using TheGameExtreme.model.gameActions.classic;
 
 namespace TheGameExtreme.model.manager
 {
     public class SoloGameManager : GameManager
     {
 
-        public SoloGameManager(int nbPlayer, List<String> players)
-            : base(nbPlayer, players)
+        public SoloGameManager(Parametreur parametreur)
+            : base(parametreur)
         {
 
         }
 
-        public override bool endTurn()
-        {
-
-            if (gameMode.checkBeforeEndTurnRule(CurrentCardPlayed, nbCardAtBeginOfTurn, CurrentHand))
-            {
-                //verifyNbCardPlay();
-                pioche();
-                currentIndexPlayer += 1;
-                if (currentIndexPlayer == playerList.Count)
-                {
-                    currentIndexPlayer = 0;
-                }
-                CurrentHand = playerList[currentIndexPlayer].getCardList();
-                OnPlayerChanged(new PlayerChangedEventArgs(CurrentHand, playerList[currentIndexPlayer].Pseudo));
-                nbCardAtBeginOfTurn = CurrentHand.Count;
-                CurrentCardPlayed.Clear();
-                if (gameMode.checkEndTurnRule(CurrentCardPlayed, nbCardAtBeginOfTurn, CurrentHand))
-                {
-                    //if (isEndGame())    // Ajouter le score en calculant les cartes restantes dans la pile et dans les mains des joueurs
+        //public override bool endTurn()
         //{
-                    //    displayWinner();
-                    //    return true;
-                    //}
 
-                    return false;
-                }
-                else
-                {
-                    return true;
-                }
-            }
-            else
-            {
-                return false;
-            }
+        //    //if (gameMode.checkBeforeEndTurnRule(CurrentCardPlayed, nbCardAtBeginOfTurn, CurrentHand))
+        //    //{
+        //    //    //verifyNbCardPlay();
+        //    //    pioche();
+        //    //    currentIndexPlayer += 1;
+        //    //    if (currentIndexPlayer == playerList.Count)
+        //    //    {
+        //    //        currentIndexPlayer = 0;
+        //    //    }
+        //    //    CurrentHand = playerList[currentIndexPlayer].getCardList();
+        //    //    OnPlayerChanged(new PlayerChangedEventArgs(CurrentHand, playerList[currentIndexPlayer].Pseudo));
+        //    //    nbCardAtBeginOfTurn = CurrentHand.Count;
+        //    //    CurrentCardPlayed.Clear();
+        //    //    if (gameMode.checkEndTurnRule(CurrentCardPlayed, nbCardAtBeginOfTurn, CurrentHand))
+        //    //    {
+        //    //        //if (isEndGame())    // Ajouter le score en calculant les cartes restantes dans la pile et dans les mains des joueurs
+        //    //        //{
+        //    //        //    displayWinner();
+        //    //        //    return true;
+        //    //        //}
+
+        //    //        return false;
+        //    //    }
+        //    //    else
+        //    //    {
+        //    //        return true;
+        //    //    }
+        //    //}
+        //    //else
+        //    //{
+        //    //    return false;
+        //    //}
 
 
-        }
+        //}
 
-        protected void verifyNbCardPlay()
-        {
-            foreach (Card cardPlayed in CurrentCardPlayed)
-            {
-                if (Equals(cardPlayed.GetType(), ThreeCard.CARD_THREE))
-                {
-                    if ((nbCardAtBeginOfTurn - CurrentHand.Count) < 3) // Penser à vérifier s'il a joué une ThreeCard pour regarder s'il a bien joué 3 cartes
-                    {
-                        testIsEndGame();
-                    }
-                    return;
-                }
-            }
-            if ((nbCardAtBeginOfTurn - CurrentHand.Count) < 2) // Penser à vérifier s'il a joué une ThreeCard pour regarder s'il a bien joué 3 cartes
-            {
-                testIsEndGame();
-            }
-        }
+        //protected void verifyNbCardPlay()
+        //{
+        //    foreach (Card cardPlayed in CurrentCardPlayed)
+        //    {
+        //        if (Equals(cardPlayed.GetType(), ThreeCard.CARD_THREE))
+        //        {
+        //            if ((nbCardAtBeginOfTurn - CurrentHand.Count) < 3) // Penser à vérifier s'il a joué une ThreeCard pour regarder s'il a bien joué 3 cartes
+        //            {
+        //                testIsEndGame();
+        //            }
+        //            return;
+        //        }
+        //    }
+        //    if ((nbCardAtBeginOfTurn - CurrentHand.Count) < 2) // Penser à vérifier s'il a joué une ThreeCard pour regarder s'il a bien joué 3 cartes
+        //    {
+        //        testIsEndGame();
+        //    }
+        //}
 
-        protected void testIsEndGame()
-        {
-            if (isEndGame())
-            {
-                displayWinner();
-            }
-            else
-            {
-                //throw new Exception("Vous n'avez pas joué assez de carte!");
-                throw new Exception(AppRessources_br.StrCardPlayedLessThanTwo);
-            }
-        }
+        //protected void testIsEndGame()
+        //{
+        //    if (isEndGame())
+        //    {
+        //        displayWinner();
+        //    }
+        //    else
+        //    {
+        //        //throw new Exception("Vous n'avez pas joué assez de carte!");
+        //        throw new Exception(AppRessources_br.StrCardPlayedLessThanTwo);
+        //    }
+        //}
 
-        protected void displayWinner()
-        {
-            if (win)
-            {
-                EndMessage = "Le jeu est terminé!\n Bravo vous avez gagné!";
-                EndMessage = AppRessource.StrWin;
-            }
-        }
+        //protected void displayWinner()
+        //{
+        //    if (win)
+        //    {
+        //        EndMessage = "Le jeu est terminé!\n Bravo vous avez gagné!";
+        //        EndMessage = AppRessource.StrWin;
+        //    }
+        //}
 
-        protected override void pioche()
-        {
-            int nbPickedCard = nbMaxCard - CurrentHand.Count;
-            for (int i = 0; i < nbPickedCard; i++)
-            {
-                if (deck.size() == 0)
-                {
-                    return;
-                }
-                int random = new Random().Next(0, deck.size() - 1);
-                playerList[currentIndexPlayer].pioche(deck.getCard(random));
-                deck.removeAt(random);
-            }
-        }
+        //protected void pioche()
+        //{
+        //    int nbPickedCard = nbMaxCard - CurrentHand.Count;
+        //    for (int i = 0; i < nbPickedCard; i++)
+        //    {
+        //        if (deck.size() == 0)
+        //        {
+        //            return;
+        //        }
+        //        int random = new Random().Next(0, deck.size() - 1);
+        //        playerList[currentIndexPlayer].pioche(deck.getCard(random));
+        //        deck.removeAt(random);
+        //    }
+        //}
 
-        protected override bool isEndGame()
-        {
-            if (CurrentHand.Count != 0)
-            {
-                List<Card> playableCard = new List<Card>();
-                tryToFindSoluce(playableCard);
-                return testEndGame(playableCard);
-            }
-            return false;
-        }
+        //protected override bool isEndGame()
+        //{
+        //    if (CurrentHand.Count != 0)
+        //    {
+        //        List<Card> playableCard = new List<Card>();
+        //        tryToFindSoluce(playableCard);
+        //        return testEndGame(playableCard);
+        //    }
+        //    return false;
+        //}
 
-        protected override void tryToFindSoluce(List<Card> playableCard)
-        {
-            CurrentHand.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)
-                {
-                    playableCard.Add(card);
-                }
-            });
-        }
+        //protected override void tryToFindSoluce(List<Card> playableCard)
+        //{
+        //    CurrentHand.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)
+        //        {
+        //            playableCard.Add(card);
+        //        }
+        //    });
+        //}
 
-        protected override bool testEndGame(List<Card> playableCard)
-        {
-            if (playableCard.Count == 2)
-            {
-                foreach (Card c in playableCard)
-                {
-                    if (Equals(c.getName(), ThreeCard.CARD_THREE))
-                    {
-                        win = false;
-                        EndMessage = "Le jeu est terminé!\n Désolé, vous avez perdu... Vous deviez jouer trois cartes à cause de l'effet \"Trois cartes joué\" hors votre jeu ne permet pas d'en jouer autant! Essayez encore!";
-                        return true;
-                    }
-                }
-            }
-            else if (playableCard.Count < 2)
-            {
-                win = false;
-                EndMessage = "Le jeu est terminé!\n Désolé, vous avez perdu... Essayez encore!";
-                return true;
-            }
-            else if (effectLose())
-            {
-                win = false;
-                EndMessage = "Désolé, vous n'avez pas recouvert la tête de mort... Réessayez ;)";
-                return true;
-            }
+        //protected override bool testEndGame(List<Card> playableCard)
+        //{
+        //    if (playableCard.Count == 2)
+        //    {
+        //        foreach (Card c in playableCard)
+        //        {
+        //            if (Equals(c.getName(), ThreeCard.CARD_THREE))
+        //            {
+        //                win = false;
+        //                EndMessage = "Le jeu est terminé!\n Désolé, vous avez perdu... Vous deviez jouer trois cartes à cause de l'effet \"Trois cartes joué\" hors votre jeu ne permet pas d'en jouer autant! Essayez encore!";
+        //                return true;
+        //            }
+        //        }
+        //    }
+        //    else if (playableCard.Count < 2)
+        //    {
+        //        win = false;
+        //        EndMessage = "Le jeu est terminé!\n Désolé, vous avez perdu... Essayez encore!";
+        //        return true;
+        //    }
+        //    else if (effectLose())
+        //    {
+        //        win = false;
+        //        EndMessage = "Désolé, vous n'avez pas recouvert la tête de mort... Réessayez ;)";
+        //        return true;
+        //    }
 
-            return false;
-        }
+        //    return false;
+        //}
 
-        protected override bool effectLose()
-        {
-            foreach (Stack<Card> orderedStack in ListOrderedStacks)
-            {
-                if (Equals(orderedStack.Peek().getName(), EndGameCard.CARD_ENDGAME))
-                {
-                    return true;
-                }
-            }
-            return false;
-        }
+        //protected override bool effectLose()
+        //{
+        //    foreach (Stack<Card> orderedStack in ListOrderedStacks)
+        //    {
+        //        if (Equals(orderedStack.Peek().getName(), EndGameCard.CARD_ENDGAME))
+        //        {
+        //            return true;
+        //        }
+        //    }
+        //    return false;
+        //}
     }
 }

TheGameExtreme/model/manager/multiplayer/LocalGameManager.cs

@@ -1,43 +1,44 @@
 using System;
 using System.Collections.Generic;
 using TheGameExtreme.model.card;
+using TheGameExtreme.model.gameActions.classic;
 
 namespace TheGameExtreme.model.manager
 {
     public class LocalGameManager : MultiplayerGameManager
     {
-        public LocalGameManager(int nbPlayer, List<string> players) : base(nbPlayer, players)
+        public LocalGameManager(Parametreur parametreur) : base(parametreur)
         {
         }
 
-        public override bool endTurn()
-        {
-            throw new NotImplementedException();
-        }
+        //public override bool endTurn()
+        //{
+        //    throw new NotImplementedException();
+        //}
 
-        protected override bool effectLose()
-        {
-            throw new NotImplementedException();
-        }
+        //protected override bool effectLose()
+        //{
+        //    throw new NotImplementedException();
+        //}
 
-        protected override bool isEndGame()
-        {
-            throw new NotImplementedException();
-        }
+        //protected override bool isEndGame()
+        //{
+        //    throw new NotImplementedException();
+        //}
 
-        protected override void pioche()
-        {
-            throw new NotImplementedException();
-        }
+        //protected override void pioche()
+        //{
+        //    throw new NotImplementedException();
+        //}
 
-        protected override bool testEndGame(List<Card> playableCard)
-        {
-            throw new NotImplementedException();
-        }
+        //protected override bool testEndGame(List<Card> playableCard)
+        //{
+        //    throw new NotImplementedException();
+        //}
 
-        protected override void tryToFindSoluce(List<Card> playableCard)
-        {
-            throw new NotImplementedException();
-        }
+        //protected override void tryToFindSoluce(List<Card> playableCard)
+        //{
+        //    throw new NotImplementedException();
+        //}
     }
 }

TheGameExtreme/model/manager/multiplayer/RemoteGameManager.cs

@@ -1,43 +1,44 @@
 using System;
 using System.Collections.Generic;
 using TheGameExtreme.model.card;
+using TheGameExtreme.model.gameActions.classic;
 
 namespace TheGameExtreme.model.manager.multiplayer
 {
     public class RemoteGameManager : MultiplayerGameManager
     {
-        public RemoteGameManager(int nbPlayer, List<string> players) : base(nbPlayer, players)
+        public RemoteGameManager(Parametreur parametreur) : base(parametreur)
         {
         }
 
-        public override bool endTurn()
-        {
-            throw new NotImplementedException();
-        }
+        //public override bool endTurn()
+        //{
+        //    throw new NotImplementedException();
+        //}
 
-        protected override bool effectLose()
-        {
-            throw new NotImplementedException();
-        }
+        //protected override bool effectLose()
+        //{
+        //    throw new NotImplementedException();
+        //}
 
-        protected override bool isEndGame()
-        {
-            throw new NotImplementedException();
-        }
+        //protected override bool isEndGame()
+        //{
+        //    throw new NotImplementedException();
+        //}
 
-        protected override void pioche()
-        {
-            throw new NotImplementedException();
-        }
+        //protected override void pioche()
+        //{
+        //    throw new NotImplementedException();
+        //}
 
-        protected override bool testEndGame(List<Card> playableCard)
-        {
-            throw new NotImplementedException();
-        }
+        //protected override bool testEndGame(List<Card> playableCard)
+        //{
+        //    throw new NotImplementedException();
+        //}
 
-        protected override void tryToFindSoluce(List<Card> playableCard)
-        {
-            throw new NotImplementedException();
-        }
+        //protected override void tryToFindSoluce(List<Card> playableCard)
+        //{
+        //    throw new NotImplementedException();
+        //}
     }
 }

TheGameExtreme/model/rule/InfinitEffect.cs

@@ -1,10 +0,0 @@
-using System;
-namespace TheGameExtreme.model.rule
-{
-    public class InfinitEffect : Rule
-    {
-        public InfinitEffect()
-        {
-        }
-    }
-}

TheGameExtreme/model/rule/RapidEffect.cs

@@ -1,38 +0,0 @@
-using System;
-namespace TheGameExtreme.model.rule
-{
-    public class RapidEffect : Rule
-    {
-        public RapidEffect()
-        {
-        }
-
-        // Checker les cartes du haut de pile et celle joué.
-
-        //protected bool effectLose()
-        //{
-        //    foreach (Stack<Card> orderedStack in ListOrderedStacks)
-        //    {
-        //        if (Equals(orderedStack.Peek().getName(), EndGameCard.CARD_ENDGAME))
-        //        {
-        //            return true;
-        //        }
-        //    }
-        //    return false;
-        //}
-
-        
-        //foreach (Card cardPlayed in CurrentCardPlayed)
-        //{
-        //    if (Equals(cardPlayed.GetType(), ThreeCard.CARD_THREE))
-        //    {
-        //        if ((nbCardAtBeginOfTurn - CurrentHand.Count) < 3)
-        //        {
-        //            return true;
-        //        }
-        //    }
-        //}
-            
-
-    }
-}

TheGameExtreme/model/rule/Rule.cs

@@ -1,15 +0,0 @@
-using System;
-using TheGameExtreme.model.card;
-
-namespace TheGameExtreme.model.rule
-{
-    public abstract class Rule
-    {
-
-        public bool Test()
-        {
-            throw new NotImplementedException();
-        }
-
-    }
-}

TheGameExtreme/model/rule/beforeEndTurnRules/BeforeEndTurnRule.cs

@@ -1,13 +0,0 @@
-using System;
-using System.Collections.Generic;
-using TheGameExtreme.model.card;
-
-namespace TheGameExtreme.model.rule.beforeEndTurnRules
-{
-    public abstract class BeforeEndTurnRule : Rule
-    {
-
-        public abstract bool Test(List<Card> CurrentCardPlayed, int nbCardAtBeginOfTurn, List<Card> CurrentHand);
-
-    }
-}

TheGameExtreme/model/rule/beforeEndTurnRules/NbCardPlay.cs

@@ -1,24 +0,0 @@
-using System;
-using System.Collections.Generic;
-using TheGameExtreme.model.card;
-
-namespace TheGameExtreme.model.rule.beforeEndTurnRules
-{
-    public class NbCardPlay : BeforeEndTurnRule
-    {
-
-        override public bool Test(List<Card> CurrentCardPlayed, int nbCardAtBeginOfTurn, List<Card> CurrentHand)
-        {
-            if (CurrentHand.Count == 0)
-            {
-                return true;
-            }
-            if ((nbCardAtBeginOfTurn - CurrentHand.Count) < 2)
-            {
-                return false;
-            }
-            return true;
-        }
-
-    }
-}

TheGameExtreme/model/rule/endTurnRules/CompleteHand.cs

@@ -1,24 +0,0 @@
-using System;
-using System.Collections.Generic;
-using TheGameExtreme.model.card;
-
-namespace TheGameExtreme.model.rule.endTurnRules
-{
-    public class CompleteHand : EndTurnRule
-    {
-
-        public static readonly String REGLE_COMPLETEHAND = "Complete Hand";
-
-        public override bool Test(List<Card> CurrentCardPlayed, int nbCardAtBeginOfTurn, List<Card> CurrentHand)
-        {
-            // Si carte qui fait piocher que d'un vérifier la bonne pioche (penser si elle vient d'être recouverte)
-            // Sinon
-            if (nbCardAtBeginOfTurn == CurrentCardPlayed.Count)
-            {
-                return true;
-            }
-            return false;
-        }
-
-    }
-}

TheGameExtreme/model/rule/endTurnRules/EndTurnRule.cs

@@ -1,13 +0,0 @@
-using System;
-using System.Collections.Generic;
-using TheGameExtreme.model.card;
-
-namespace TheGameExtreme.model.rule.endTurnRules
-{
-    public abstract class EndTurnRule : Rule
-    {
-
-        public abstract bool Test(List<Card> CurrentCardPlayed, int nbCardAtBeginOfTurn, List<Card> CurrentHand);
-
-    }
-}

TheGameExtreme/model/rule/endTurnRules/VoidDeck.cs

@@ -1,17 +0,0 @@
-using System;
-using System.Collections.Generic;
-using TheGameExtreme.model.card;
-
-namespace TheGameExtreme.model.rule.endTurnRules
-{
-    public class VoidDeck : EndTurnRule
-    {
-
-        public static readonly String REGLE_VOIDDECK = "Void Deck";
-
-        public override bool Test(List<Card> CurrentCardPlayed, int nbCardAtBeginOfTurn, List<Card> CurrentHand)
-        {
-            throw new NotImplementedException();
-        }
-    }
-}

TheGameExtreme/model/rule/playRules/Ascendant.cs

@@ -1,22 +0,0 @@
-using System;
-using System.Collections.Generic;
-using TheGameExtreme.model.card;
-
-namespace TheGameExtreme.model.rule.playRules
-{
-    public class Ascendant : PlayRule
-    {
-
-        public static readonly String REGLE_ASCENDANT = "Ascendant";
-
-        override public bool Test(Card playedCard, Stack<Card> stack, bool bottomUp, List<Card> CurrentHand)
-        {
-            if (bottomUp && playedCard.Value > stack.Peek().Value)
-            {
-                return true;
-            }
-            return false;
-        }
-
-    }
-}

TheGameExtreme/model/rule/playRules/Descendant.cs

@@ -1,21 +0,0 @@
-using System;
-using System.Collections.Generic;
-using TheGameExtreme.model.card;
-
-namespace TheGameExtreme.model.rule.playRules
-{
-    public class Descendant : PlayRule
-    {
-
-        public static readonly String REGLE_DESCENDANT = "Descendant";
-
-        override public bool Test(Card playedCard, Stack<Card> stack, bool bottomUp, List<Card> CurrentHand)
-        {
-            if (!bottomUp && playedCard.Value < stack.Peek().Value)
-            {
-                return true;
-            }
-            return false;
-        }
-    }
-}

TheGameExtreme/model/rule/playRules/PasDeDix.cs

@@ -1,22 +0,0 @@
-using System;
-using System.Collections.Generic;
-using TheGameExtreme.model.card;
-
-namespace TheGameExtreme.model.rule.playRules
-{
-    public class PasDeDix : PlayRule
-    {
-
-        public static readonly String REGLE_PASDEDIX = "PasDeDix";
-
-        override public bool Test(Card playedCard, Stack<Card> stack, bool bottomUp, List<Card> CurrentHand)
-        {
-            if ((stack.Peek().Value + 10) == playedCard.Value || (stack.Peek().Value - 10) == playedCard.Value)
-            {
-                return true;
-            }
-            return false;
-        }
-
-    }
-}

TheGameExtreme/model/rule/playRules/PlayRule.cs

@@ -1,11 +0,0 @@
-using System;
-using System.Collections.Generic;
-using TheGameExtreme.model.card;
-
-namespace TheGameExtreme.model.rule.playRules
-{
-    public abstract class PlayRule : Rule
-    {
-        public abstract bool Test(Card playedCard, Stack<Card> stack, bool bottomUp, List<Card> CurrentHand);
-    }
-}

TheGameExtreme/model/rule/playRules/VoidHand.cs

@@ -1,22 +0,0 @@
-using System;
-using System.Collections.Generic;
-using TheGameExtreme.model.card;
-
-namespace TheGameExtreme.model.rule.playRules
-{
-    public class VoidHand : PlayRule
-    {
-
-        public static readonly String REGLE_VOIDHAND = "Void Hand";
-
-        override public bool Test(Card playedCard, Stack<Card> stack, bool bottomUp, List<Card> CurrentHand)
-        {
-            if (CurrentHand.Count == 0)
-            {
-                return false;
-            }
-            return true;
-        }
-
-    }
-}

TheGameExtreme/view/MainPage.xaml.cs

@@ -33,12 +33,19 @@ namespace TheGameExtreme.view
 
             viewmodel.BindingChanged += OnBindingChanged;
 
+            //viewmodel.PlayerChanged += OnPlayerChanged;
+
             Alert.SetBinding(Label.TextProperty, new Binding("Alert", source: viewmodel));
             pseudo.SetBinding(Label.TextProperty, new Binding("Pseudo", source: viewmodel));
 
             inflateHand();
         }
 
+        //private void OnPlayerChanged(object sender, PlayerChangedEventArgs args)
+        //{
+        //    inflateHand();
+        //}
+
         private void inflateHand()
         {
             Hand.Children.Clear();
@@ -145,6 +152,7 @@ namespace TheGameExtreme.view
 
         private void endTurn(object sender, EventArgs args)
         {
+            viewmodel.Alert = "";
             if (viewmodel.endTurn())
             {
                 botPanel.Children.Add(button);

TheGameExtreme/viewmodel/CardVM.cs

@@ -0,0 +1,33 @@
+using System;
+using System.ComponentModel;
+using TheGameExtreme.model.card;
+
+namespace TheGameExtreme.viewmodel
+{
+    public class CardVM : INotifyPropertyChanged
+    {
+
+        public event PropertyChangedEventHandler PropertyChanged;
+        public Card View { get; set; }
+        private int value;
+        public int Value {
+            get { return value; }
+            set
+            {
+                this.value = value;
+                OnPropertyChanged("Value");
+            }
+        }
+        protected virtual void OnPropertyChanged(string info)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(info));
+        }
+
+        public CardVM(Card view)
+        {
+            View = view;
+
+            Value = view.Value;
+        }
+    }
+}

TheGameExtreme/viewmodel/Main.cs

@@ -2,8 +2,10 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.ComponentModel;
+using TheGameExtreme.model;
 using TheGameExtreme.model.card;
 using TheGameExtreme.model.@event;
+using TheGameExtreme.model.gameActions.classic;
 using TheGameExtreme.model.manager;
 
 namespace TheGameExtreme.viewmodel
@@ -11,8 +13,10 @@ namespace TheGameExtreme.viewmodel
     public class Main : INotifyPropertyChanged
     {
 
+        //public event EventHandler<PlayerChangedEventArgs> PlayerChanged;
         public event EventHandler<TopRangeChangedEventArgs> BindingChanged;
         public event PropertyChangedEventHandler PropertyChanged;
+        private List<PlayerVM> players = new List<PlayerVM>();
         private string alert = "";
         public String Alert
         {
@@ -45,14 +49,20 @@ namespace TheGameExtreme.viewmodel
 
         public Main()
         {
-            gameManager = new SoloGameManager(2, new List<String> { "Clément", "Baptiste" }) ;  // Donner le nom des joueurs
+            List<string> playersNames = new List<string> { "Clément", "Baptiste" };
+            playersNames.ForEach(name => players.Add(new PlayerVM(new Player(name))));
+            Parametreur parametreur = new Parametreur(new GameMode());
+            players.ForEach(player => parametreur.AddPlayer(player.View));
+            gameManager = new SoloGameManager(parametreur) ;  // Donner le nom des joueurs
 
-            gameManager.TopRangeChanged += OnTopRangeChanged;
+            gameManager.TopRangeChanged += OnBindingChanged;
 
             gameManager.PlayerChanged += OnPlayerChanged;
 
             CurrentHand = gameManager.CurrentHand;
 
+            Pseudo = players[0].Pseudo;
+
             //ListOrderedStacks = new ObservableCollection<Stack<Card>>(gameManager.ListOrderedStacks);
         }
 
@@ -60,70 +70,111 @@ namespace TheGameExtreme.viewmodel
         {
             CurrentHand = args.NewCurrentHand;
             Pseudo = args.Pseudo;
+            //PlayerChanged?.Invoke(this, args);
         }
 
-        public void OnTopRangeChanged(object source, TopRangeChangedEventArgs args)
+        public void OnBindingChanged(object source, TopRangeChangedEventArgs args)
         {
             BindingChanged?.Invoke(this, args);
         }
 
-        /**
-         *
-         *
-         * @return booléen de fin de jeu
-         */
-        public bool played(int numStack, int valueCard)
-        {
-            if (gameManager.isCanPlay())
-            {
-                return playOneCard(numStack, valueCard);
-            }
-            else
-            {
-                Alert = "Le joueur n'a plus de carte dans sa main!";
-                // Faire un toast
-                return false;
-            }
-        }
+
+
+
+
+
+
 
         /**
          *
          *
          * @return booléen de fin de jeu
          */
-        private bool playOneCard(int numStack, int valueCard)
-        {
-            try
+        public bool played(int numStack, int valueCard)
         {
+            //try
+            //{
                 gameManager.joue(valueCard, numStack);
-                if (gameManager.EndMessage != null)
-                {
+
                 Alert = gameManager.EndMessage;
-                    return true;
-                }
-            }
-            catch(Exception e)
-            {
-                // Faire un toast
-                Alert = e.Message;
-            }
+
+                //if (gameManager.EndMessage != null)
+                //{
+                //    Alert = gameManager.EndMessage;
+                //    return true;
+                //}
                 return false;
+            //}
+            //catch (Exception e)
+            //{
+            //    // Faire un toast
+            //    Alert = e.Message;
+            //}
+            //return false;
+
+
+
+
+            //if (gameManager.isCanPlay())
+            //{
+            //    return playOneCard(numStack, valueCard);
+            //}
+            //else
+            //{
+            //    Alert = "Le joueur n'a plus de carte dans sa main!";
+            //    // Faire un toast
+            //    return false;
+            //}
         }
 
         public bool endTurn()
-        {
-            try
         {
             bool isEnd = gameManager.endTurn();
             Alert = gameManager.EndMessage;
             return isEnd;
         }
-            catch(Exception e)
-            {
-                Alert = e.Message;
-                return false;
-            }
-        }
+
+
+
+
+        ///**
+        // *
+        // * 
+        // * @return booléen de fin de jeu
+        // */
+        //private bool playOneCard(int numStack, int valueCard)
+        //{
+        //    try
+        //    {
+        //        gameManager.joue(valueCard, numStack);
+        //        if (gameManager.EndMessage != null)
+        //        {
+        //            Alert = gameManager.EndMessage;
+        //            return true;
+        //        }
+        //    }
+        //    catch(Exception e)
+        //    {
+        //        // Faire un toast
+        //        Alert = e.Message;
+        //    }
+        //    return false;
+        //}
+
+        //public bool endTurn()
+        //{
+        //    try
+        //    {
+        //        bool isEnd = gameManager.endTurn();
+        //        Alert = gameManager.EndMessage;
+        //        return isEnd;
+        //    }
+        //    catch(Exception e)
+        //    {
+        //        Alert = e.Message;
+        //        return false;
+        //    }
+        //}
 
     }
 }

TheGameExtreme/viewmodel/PlayerVM.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using TheGameExtreme.model;
+using TheGameExtreme.model.card;
+using TheGameExtreme.model.@event;
+
+namespace TheGameExtreme.viewmodel
+{
+    public class PlayerVM
+    {
+
+        public Player View { get; set; }
+        public string Pseudo { get; set; }
+        private List<CardVM> cardList = new List<CardVM>();
+        //public event EventHandler<HandCardChangedEventArgs> HandCardChanged;
+
+        public PlayerVM(Player view)
+        {
+            View = view;
+
+            Pseudo = view.Pseudo;
+            view.getCardList().ForEach(card => cardList.Add(new CardVM(card)));
+
+            View.HandCardChanged += OnHandCardChanged;
+        }
+
+        private void OnHandCardChanged(object sender, HandCardChangedEventArgs args)
+        {
+            if (args.NewCard == null)
+            {
+                cardList.RemoveAt(args.Position);
+            }
+            else
+            {
+                cardList.Insert(args.Position, new CardVM(args.NewCard));
+            }
+        }
+
+        public void pioche(CardVM card)
+        {
+            View.pioche(card.View);
+        }
+
+        public List<CardVM> getCardList()
+        {
+            return cardList;
+        }
+    }
+}