Avancement sur le remodelamodelage du model

TheGameExtreme/model/gameActions/Piles.cs

@@ -7,7 +7,7 @@ namespace TheGameExtreme.model.gameActions
     public class Piles
     {
 
-        public List<Stack<Card>> ListOrderedStacks { get; set; }
+        private List<Stack<Card>> ListOrderedStacks { get; set; }
 
         public Piles()
         {

TheGameExtreme/model/gameActions/classic/GameMode.cs

@@ -1,6 +1,8 @@
 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
@@ -10,40 +12,136 @@ namespace TheGameExtreme.model.gameActions.classic
 
         protected List<GameAction> gameActions;
         protected Piles piles;
+        public event EventHandler<TopRangeChangedEventArgs> TopRangeChanged;
+        protected int nbCardAtBeginOfTurn = 7;
+        protected Deck deck;
+        private int nbMaxCard;
 
         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);
         }
 
-        public void load()
+        protected void createDeck()
         {
-            piles = new Piles();
+            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()
+        public void pioche(List<Card> CurrentHand, Player player)
         {
-            ((Piocher)gameActions[0]).pioche();
+            ((Piocher)gameActions[0]).pioche(CurrentHand, deck, player);
         }
 
         public void playCard(int valueCard, List<Card> CurrentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed)
         {
-            ((JouerUneCarte)gameActions[1]).play(valueCard, CurrentHand, orderedStackSelected, player, CurrentCardPlayed);
+            if (((JouerUneCarte)gameActions[1]).play(valueCard, CurrentHand, orderedStackSelected, player, CurrentCardPlayed))
-            if (CurrentHand.Count == 0)
             {
-                endTurn(); // Presque bon, oublie juste d'afficher les nouvelles cartes
+                OnTopRangeChanged(new TopRangeChangedEventArgs(piles.getStack(orderedStackSelected).Peek(), ((JouerUneCarte)gameActions[1]).OldCard, orderedStackSelected));
+            }
         }
+
+        protected internal void OnTopRangeChanged(TopRangeChangedEventArgs args)
+        {
+            TopRangeChanged?.Invoke(this, args);
         }
 
-        public void endTurn()
+        public bool endTurn(List<Card> CurrentHand, List<Card> CurrentCardPlayed, Player player)
         {
-            ((TerminerSonTour)gameActions[2]).end();
+            ((TerminerSonTour)gameActions[2]).end(CurrentHand, nbCardAtBeginOfTurn, CurrentCardPlayed);
+            pioche(CurrentHand, player);
+            //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 (isEndGame())    // Ajouter le score en calculant les cartes restantes dans la pile et dans les mains des joueurs
+            //{
+            //    displayWinner();
+            //    return true;
+            //}
+            //else
+            //{
+            //    return true;
+            //}
+            return false; // Changer
         }
 
+        //protected void displayWinner()
+        //{
+        //    if (win)
+        //    {
+        //        EndMessage = "Le jeu est terminé!\n Bravo vous avez gagné!";
+        //        EndMessage = AppRessource.StrWin;
+        //    }
+        //}
+
+
+
+
+
+
+
+
+
+
+
+
+
 
         //    private List<Rule> playRule = new List<Rule>();
         //    private List<Rule> beforeEndTurnRule = new List<Rule>();

TheGameExtreme/model/gameActions/classic/JouerUneCarte.cs

@@ -7,11 +7,13 @@ namespace TheGameExtreme.model.gameActions.classic
     public class JouerUneCarte : GameAction
     {
 
+        public Card OldCard { get; set; }
+
         public JouerUneCarte(Piles ListOrderedStacks) : base(ListOrderedStacks)
         {
         }
 
-        public void play(int valueCard, List<Card> CurrentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed)
+        public bool play(int valueCard, List<Card> CurrentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed)
         {
             foreach (Card card in CurrentHand)
             {
@@ -21,30 +23,32 @@ namespace TheGameExtreme.model.gameActions.classic
                     {
                         if (orderedStackSelected < 2)
                         {
-                            rule(card, ListOrderedStacks.getStack(orderedStackSelected), true, player, CurrentCardPlayed);
+                            return rule(card, ListOrderedStacks.getStack(orderedStackSelected), true, player, CurrentCardPlayed);
                         }
                         else
                         {
-                            rule(card, ListOrderedStacks.getStack(orderedStackSelected), false, player, CurrentCardPlayed);
+                            return rule(card, ListOrderedStacks.getStack(orderedStackSelected), false, player, CurrentCardPlayed);
                         }
                     }
                     else
                     {
                         throw new Exception(AppRessource.StrCantGetStack);
                     }
-                    return;
                 }
             }
+            return false;
         }
 
-        private void rule(Card card, Stack<Card> stack, bool bottomUp, Player player, List<Card> CurrentCardPlayed)
+        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)
             {
-                Card oldCard = stack.Peek();
+                OldCard = stack.Peek();
                 player.joue(card);
                 CurrentCardPlayed.Add(card);
                 stack.Push(card);
+
+                return true;
                 //OnTopRangeChanged(new TopRangeChangedEventArgs(card, oldCard, ListOrderedStacks.IndexOf(orderedStack)));
             }
             else

TheGameExtreme/model/gameActions/classic/Piocher.cs

@@ -6,6 +6,9 @@ namespace TheGameExtreme.model.gameActions.classic
 {
     public class Piocher : GameAction
     {
+
+        protected int nbMaxCard = 7; // Changer
+
         public Piocher(Piles ListOrderedStacks) : base(ListOrderedStacks)
         {
         }
@@ -15,9 +18,19 @@ namespace TheGameExtreme.model.gameActions.classic
             return true;
         }
 
-        public void pioche()
+        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

@@ -1,4 +1,8 @@
 using System;
+using System.Collections.Generic;
+using TheGameExtreme.model.card;
+using TheGameExtreme.model.card.rapidCard;
+
 namespace TheGameExtreme.model.gameActions.classic
 {
     public class TerminerSonTour : GameAction
@@ -7,9 +11,56 @@ namespace TheGameExtreme.model.gameActions.classic
         {
         }
 
-        public void end()
+        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 || (nbCardAtBeginOfTurn - CurrentHand.Count) >= 2)
+            {   // Ne pas oublié de gérer les ThreeCard
+                return Test(CurrentHand);
+            }
+            return false;
+        }
+
+        public bool Test(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 > 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);
+                }
+            });
+        }
+
+        protected bool testEndGame(List<Card> playableCard)
+        {
+            if (playableCard.Count == 2)
+            {
+                foreach (Card c in playableCard)
+                {
+                    if (Equals(c.getName(), ThreeCard.CARD_THREE))
+                    {
+                        return false;
+                    }
+                }
+            }
+            else if (playableCard.Count < 2)
+            {
+                return false;
+            }
+            return true;
         }
     }
 }

TheGameExtreme/model/manager/GameManager.cs

@@ -17,7 +17,6 @@ namespace TheGameExtreme.model.manager
         /* 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 Deck deck;
         public readonly int nbPlayer;
         protected List<Player> players = new List<Player>();
         public event EventHandler<TopRangeChangedEventArgs> TopRangeChanged;
@@ -39,63 +38,28 @@ namespace TheGameExtreme.model.manager
             playersNames.ForEach(playerName => players.Add(new Player(playerName)));
 
             this.gameMode = gameMode;
-            gameMode.load();
+            gameMode.load(nbPlayer, players);
 
-            ListOrderedStacks = new Piles();
+            gameMode.TopRangeChanged += OnTopRangeChanged;
-
-            createDeck();
-            defineNbMaxCard();
-            distribueCard();
 
             CurrentHand = players[0].getCardList();
         }
 
-        protected void createDeck()
-        {
-            switch (true)
-            {
-                case false:
-                    deck = new ClassicDeck();
-                    break;
         
-                default:
-                    deck = new ExtremeDeck();
-                    break;
-            }
-        }
 
-        protected void defineNbMaxCard()
+        public void joue(int valueCard, int orderedStackSelected)
-        {
-            switch (nbPlayer)
         {
-                case 1:
+            gameMode.playCard(valueCard, CurrentHand, orderedStackSelected, players[0], CurrentCardPlayed); // Mettre le joueur actif
-                    nbMaxCard = 8;
-                    break;
-                case 2:
-                    nbMaxCard = 7;
-                    break;
-                default:
-                    nbMaxCard = 6;
-                    break;
-            }
         }
 
-        protected void distribueCard()
+        public bool endTurn()
-        {
-            for (int i = 0; i < nbMaxCard; i++)
-            {
-                players.ForEach(player =>
         {
-                    int r = new Random().Next(0, deck.size() - 1);
+            return gameMode.endTurn(CurrentHand, CurrentCardPlayed, players[0]); // Mettre le joueur actif
-                    player.pioche(deck.getCard(r));
-                    deck.removeAt(r);
-                });
-            }
         }
 
-        public void joue(int valueCard, int orderedStackSelected)
+        public void OnTopRangeChanged(object source, TopRangeChangedEventArgs args)
         {
-            gameMode.playCard(valueCard, CurrentHand, orderedStackSelected, players[0], CurrentCardPlayed); // Mettre le joueur actif
+            TopRangeChanged?.Invoke(this, args);
         }
 
 

TheGameExtreme/model/rule/endTurnRules/CompleteHand.cs

@@ -11,7 +11,7 @@ namespace TheGameExtreme.model.rule.endTurnRules
 
         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)
+            // 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)
             {

TheGameExtreme/view/MainPage.xaml.cs

@@ -145,14 +145,14 @@ namespace TheGameExtreme.view
 
         private void endTurn(object sender, EventArgs args)
         {
-            //if (viewmodel.endTurn())
+            if (viewmodel.endTurn())
-            //{
+            {
-            //    botPanel.Children.Add(button);
+                botPanel.Children.Add(button);
-            //}
+            }
-            //else
+            else
-            //{
+            {
-            //    inflateHand();
+                inflateHand();
-            //}
+            }
         }
     }
 }

TheGameExtreme/viewmodel/Main.cs

@@ -113,6 +113,24 @@ namespace TheGameExtreme.viewmodel
             //}
         }
 
+        public bool endTurn()
+        {
+            try
+            {
+                bool isEnd = gameManager.endTurn();
+                Alert = gameManager.EndMessage;
+                return isEnd;
+            }
+            catch (Exception e)
+            {
+                Alert = e.Message;
+                return false;
+            }
+        }
+
+
+
+
         ///**
         // *
         // *