Implémentation des différentes fonctionnalitées de pile

TheGameExtreme/TheGameExtreme.csproj

@@ -24,6 +24,7 @@
     <Folder Include="Media\" />
     <Folder Include="model\card\cardType\" />
     <Folder Include="model\piles\" />
+    <Folder Include="model\gameActions\decimals\" />
   </ItemGroup>
   <ItemGroup>
     <Compile Remove="model\effect\StopColm.cs" />

TheGameExtreme/model/deck/CentaineDeck.cs

@@ -1,10 +1,21 @@
 using System;
+using TheGameExtreme.model.card;
+using TheGameExtreme.model.card.cardType;
+
 namespace TheGameExtreme.model.deck
 {
-    public class CentaineDeck
+    public class CentaineDeck : Deck
     {
         public CentaineDeck()
         {
+            decimal d;
+            Random random = new Random();
+
+            for (int i = -499; i <= 499; i += 10)
+            {
+                d = (decimal)(random.Next(i, i+10)) / 100;
+                deck.Add(new ClassicCard(d));
+            }
         }
     }
 }

TheGameExtreme/model/deck/ClassicDeck.cs

@@ -8,11 +8,9 @@ namespace TheGameExtreme.model.deck
     {
         public ClassicDeck()
         {
-            Card card;
             for (int i = 2; i <= 99; i++)
             {
-                card = new ClassicCard(i);
+                deck.Add(new ClassicCard(i));
-                deck.Add(card);
             }
         }
     }

TheGameExtreme/model/deck/DecimalDeck.cs

@@ -8,11 +8,9 @@ namespace TheGameExtreme.model.deck
     {
         public DecimalDeck()
         {
-            Card card;
             for (decimal i = 0.02m; i <= 0.99m; i += 0.01m)
             {
-                card = new ClassicCard(i);
+                deck.Add(new ClassicCard(i));
-                deck.Add(card);
             }
         }
     }

TheGameExtreme/model/deck/Deck.cs

@@ -23,5 +23,42 @@ namespace TheGameExtreme.model.deck
         {
             return deck[index];
         }
+
+        protected void InsertionDichotomique(List<Card> deck, int start, int end, Card card)
+        {
+            int mediane = (end - start) % 2 + start;
+            if (mediane > deck.Count - 1)
+            {
+                deck.Add(card);
+                return;
+            }
+            int comparateur = deck[mediane].Value.CompareTo(card.Value);
+            if (mediane == end)
+            {
+                if (comparateur > 0)
+                {
+                    deck.Insert(start, card);
+                }
+                else
+                {
+                    deck.Insert(end, card);
+                }
+                return;
+            }
+            if (comparateur == 0)
+            {
+                return;
+            }
+            else if (comparateur > 0)
+            {
+                InsertionDichotomique(deck, start, mediane, card);
+                return;
+            }
+            else
+            {
+                InsertionDichotomique(deck, mediane, end, card);
+                return;
+            }
+        }
     }
 }

TheGameExtreme/model/deck/DizaineDeck.cs

@@ -8,15 +8,9 @@ namespace TheGameExtreme.model.deck
     {
         public DizaineDeck()
         {
-            Card card;
+            for (decimal i = -4.9m; i <= 4.9m; i += 0.1m)
-            decimal d;
-            Random random = new Random();
-            while (deck.Count < 99)
             {
-                d = (decimal)(random.Next(1, 49)) / 10;
+                deck.Add(new ClassicCard(i));
-                // Recherche dicotomique pour insertion -> si déjà insérer break et grâce au while, il continuera le bon nombre de fois.
-                card = new ClassicCard(d);
-                deck.Add(card);
             }
         }
     }

TheGameExtreme/model/deck/MilliemeDeck.cs

@@ -1,10 +1,21 @@
 using System;
+using TheGameExtreme.model.card;
+using TheGameExtreme.model.card.cardType;
+
 namespace TheGameExtreme.model.deck
 {
-    public class MilliemeDeck
+    public class MilliemeDeck : Deck
     {
         public MilliemeDeck()
         {
+            decimal d;
+            Random random = new Random();
+
+            for (int i = -4999; i <= 4999; i += 100)
+            {
+                d = (decimal)(random.Next(i, i + 100)) / 1000;
+                deck.Add(new ClassicCard(d));
+            }
         }
     }
 }

TheGameExtreme/model/deck/_50Range100Deck.cs

@@ -8,11 +8,9 @@ namespace TheGameExtreme.model.deck
     {
         public _50Range100Deck()
         {
-            Card card;
             for (int i = -49; i <= 49; i++)
             {
-                card = new ClassicCard(i);
+                deck.Add(new ClassicCard(i));
-                deck.Add(card);
             }
         }
     }

TheGameExtreme/model/gameActions/classic/JouerUneCarte.cs

@@ -27,12 +27,12 @@ namespace TheGameExtreme.model.gameActions.classic
                         if (orderedStackSelected < (ListOrderedStacks.Size * 0.5))
                         {
                             ErrorMessage = null;
-                            success = rule(card, ListOrderedStacks.getStack(orderedStackSelected), true, player, CurrentCardPlayed);
+                            success = Rule(card, ListOrderedStacks.getStack(orderedStackSelected), true, player, CurrentCardPlayed);
                         }
                         else
                         {
                             ErrorMessage = null;
-                            success = rule(card, ListOrderedStacks.getStack(orderedStackSelected), false, player, CurrentCardPlayed);
+                            success = Rule(card, ListOrderedStacks.getStack(orderedStackSelected), false, player, CurrentCardPlayed);
                         }
                         if (success)
                         {
@@ -50,7 +50,7 @@ namespace TheGameExtreme.model.gameActions.classic
             return false;
         }
 
-        private bool rule(Card card, Stack<Card> stack, bool bottomUp, Player player, List<Card> CurrentCardPlayed)
+        protected 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.CompareTo(stack.Peek().Value - 10) == 0 || card.Value.CompareTo(stack.Peek().Value + 10) == 0)
             {

TheGameExtreme/model/gameActions/classic/TerminerSonTour.cs

@@ -53,12 +53,13 @@ namespace TheGameExtreme.model.gameActions.classic
                             playableCard.Add(card);
                         }
                     }
-                    else
+                    else if (card.Value < ListOrderedStacks.getStack(i).Peek().Value)
                     {
-                        if (card.Value < ListOrderedStacks.getStack(i).Peek().Value)
+                        playableCard.Add(card);
-                        {
+                    }
-                            playableCard.Add(card);
+                    else if (card.Value.CompareTo(ListOrderedStacks.getStack(i).Peek().Value - 10) == 0 || card.Value.CompareTo(ListOrderedStacks.getStack(i).Peek().Value + 10) == 0)
-                        }
+                    {
+                        playableCard.Add(card);
                     }
                 }
             });
@@ -66,17 +67,18 @@ namespace TheGameExtreme.model.gameActions.classic
 
         protected bool testEndGame(List<Card> playableCard)
         {
-            if (playableCard.Count == 2)
+            //if (playableCard.Count == 2)
-            {
+            //{
-                foreach (Card c in playableCard)
+            //    foreach (Card c in playableCard)
-                {
+            //    {
-                    if (Equals(c.getName(), ThreeCard.CARD_THREE))
+            //        if (Equals(c.getName(), ThreeCard.CARD_THREE))
-                    {
+            //        {
-                        return false;
+            //            return false;
-                    }
+            //        }
-                }
+            //    }
-            }
+            //}
-            else if (playableCard.Count < 2)
+            //else
+            if (playableCard.Count < 2)
             {
                 return false;
             }

TheGameExtreme/model/gameActions/decimals/GameModeDecimal.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using TheGameExtreme.model.card;
+using TheGameExtreme.model.deck;
+using TheGameExtreme.model.gameActions.classic;
+using TheGameExtreme.model.piles;
+
+namespace TheGameExtreme.model.gameActions.decimals
+{
+    public class GameModeDecimal : GameMode
+    {
+        public GameModeDecimal(Piles piles, Deck deck) : base(piles, deck)
+        {
+        }
+
+        new public void load(int nbPlayer, List<Player> players)
+        {
+            base.load(nbPlayer, players);
+            gameActions.RemoveAt(1);
+            gameActions.RemoveAt(2);
+            gameActions.Add(new JouerUneCarteDecimal(Piles));
+            gameActions.Add(new TerminerSonTourDecimal(Piles));
+        }
+
+        new public bool playCard(decimal valueCard, List<Card> currentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed)
+        {
+            Message = null;
+            if (((JouerUneCarteDecimal)gameActions[1]).play(valueCard, currentHand, orderedStackSelected, player, CurrentCardPlayed))
+            {
+                return true;
+            }
+            else
+            {
+                Message = ((JouerUneCarte)gameActions[1]).ErrorMessage;
+                return false;
+            }
+        }
+
+        new public bool endTurn(List<Card> currentHand, List<Card> CurrentCardPlayed, Player player)
+        {
+            Message = null;
+            if (((TerminerSonTourDecimal)gameActions[2]).end(currentHand, CurrentCardPlayed))
+            {
+                pioche(currentHand, player);
+                CurrentCardPlayed.Clear();
+                OnPlayerChanged(null);
+                return end;
+            }
+            else
+            {
+                Message = ((TerminerSonTour)gameActions[2]).ErrorMessage;
+                return false;
+            }
+        }
+
+        new public void TestEndGame(List<Card> currentHand)
+        {
+            if (((TerminerSonTourDecimal)gameActions[2]).Test(currentHand))
+            {
+                end = false;
+            }
+            else
+            {
+                OnEndGame(new EventArgs());
+                end = true;
+            }
+        }
+    }
+}

TheGameExtreme/model/gameActions/decimals/JouerUneCarteDecimal.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using TheGameExtreme.model.card;
+using TheGameExtreme.model.gameActions.classic;
+using TheGameExtreme.model.piles;
+
+namespace TheGameExtreme.model.gameActions.decimals
+{
+    public class JouerUneCarteDecimal : JouerUneCarte
+    {
+        public JouerUneCarteDecimal(Piles ListOrderedStacks) : base(ListOrderedStacks)
+        {
+        }
+
+        new protected 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))
+            {
+                OldCard = stack.Peek();
+                player.joue(card);
+                CurrentCardPlayed.Add(card);
+                stack.Push(card);
+                return true;
+            }
+            else if (card.Value.CompareTo(stack.Peek().Value - 0.1m) == 0 || card.Value.CompareTo(stack.Peek().Value + 0.1m) == 0 || card.Value.CompareTo(stack.Peek().Value - 0.01m) == 0 || card.Value.CompareTo(stack.Peek().Value + 0.01m) == 0 || card.Value.CompareTo(stack.Peek().Value - 0.001m) == 0 || card.Value.CompareTo(stack.Peek().Value + 0.001m) == 0)
+            {
+                OldCard = stack.Peek();
+                player.joue(card);
+                CurrentCardPlayed.Add(card);
+                stack.Push(card);
+                return true;
+            }
+            else
+            {
+                ErrorMessage = AppRessource.StrWrongStack;
+                return false;
+            }
+        }
+    }
+}

TheGameExtreme/model/gameActions/decimals/TerminerSonTourDecimal.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using TheGameExtreme.model.card;
+using TheGameExtreme.model.gameActions.classic;
+using TheGameExtreme.model.piles;
+
+namespace TheGameExtreme.model.gameActions.decimals
+{
+    public class TerminerSonTourDecimal : TerminerSonTour
+    {
+        public TerminerSonTourDecimal(Piles ListOrderedStacks) : base(ListOrderedStacks)
+        {
+        }
+
+        new protected void tryToFindSoluce(List<Card> playableCard, List<Card> CurrentHand)
+        {
+            CurrentHand.ForEach(card =>
+            {
+                for (int i = 0; i < ListOrderedStacks.Size; i++)
+                {
+                    if (i < (ListOrderedStacks.Size * 0.5))
+                    {
+                        if (card.Value > ListOrderedStacks.getStack(i).Peek().Value)
+                        {
+                            playableCard.Add(card);
+                        }
+                    }
+                    else if (card.Value < ListOrderedStacks.getStack(i).Peek().Value)
+                    {
+                        playableCard.Add(card);
+                    }
+                    else if (card.Value.CompareTo(ListOrderedStacks.getStack(i).Peek().Value - 0.1m) == 0 || card.Value.CompareTo(ListOrderedStacks.getStack(i).Peek().Value + 0.1m) == 0 || card.Value.CompareTo(ListOrderedStacks.getStack(i).Peek().Value - 0.01m) == 0 || card.Value.CompareTo(ListOrderedStacks.getStack(i).Peek().Value + 0.01m) == 0 || card.Value.CompareTo(ListOrderedStacks.getStack(i).Peek().Value - 0.001m) == 0 || card.Value.CompareTo(ListOrderedStacks.getStack(i).Peek().Value + 0.001m) == 0)
+                    {
+                        playableCard.Add(card);
+                    }
+                }
+            });
+        }
+
+        new protected bool testEndGame(List<Card> playableCard)
+        {
+            if (playableCard.Count < 2)
+            {
+                return false;
+            }
+            return true;
+        }
+    }
+}

TheGameExtreme/model/piles/DecimalPilesMoins5To5.cs

@@ -3,20 +3,20 @@ using TheGameExtreme.model.card.cardType;
 
 namespace TheGameExtreme.model.piles
 {
-    public class DecimalPiles : Piles
+    public class DecimalPilesMoins5To5 : Piles
     {
 
-        public DecimalPiles(int nbPile) : base(nbPile)
+        public DecimalPilesMoins5To5(int nbPile) : base(nbPile)
         {
             for (int i = 0; i < nbPile; i++)
             {
                 if (i < (nbPile * 0.5))
                 {
-                    ListOrderedStacks[i].Push(new ClassicCard(0.01m));
+                    ListOrderedStacks[i].Push(new ClassicCard(-5m));
                 }
                 else
                 {
-                    ListOrderedStacks[i].Push(new ClassicCard(1m));
+                    ListOrderedStacks[i].Push(new ClassicCard(5m));
                 }
             }
         }

TheGameExtreme/view/GamePreparationPage.xaml.cs

@@ -8,8 +8,8 @@ namespace TheGameExtreme.view
     public partial class GamePreparationPage : ContentPage
     {
         public List<int> listNbPlayer = new List<int> { 1, 2, 3, 4, 5 };
-        public List<string> listGameMode = new List<string> { "entières",  "relatives", "décimales", "fractionnées" };
+        public List<string> listGameMode = new List<string> { "entières",  "relatives", "décimales", "dizaine", "centaine", "millième", "fractionnées" };
-        public List<int> listNbStack = new List<int> { 4, 5, 6, 7, 8 };
+        public List<int> listNbStack = new List<int> { 4, 6, 8 };
  
 
         public GamePreparationPage()
@@ -47,7 +47,7 @@ namespace TheGameExtreme.view
                 }
             }
 
-            await Navigation.PushAsync(new MainPage(playersNames));
+            await Navigation.PushAsync(new MainPage(playersNames, (int)SelectNbStack.SelectedItem, (int)SelectMode.SelectedIndex));
         }
 
         private void ChangedPseudo(object sender, EventArgs args)

TheGameExtreme/view/MainPage.xaml.cs

@@ -22,23 +22,27 @@ namespace TheGameExtreme.view
     {
         private Main viewmodel;
         Button button;
-        List<string> playersNames;
+        private List<string> playersNames;
+        private int nbPile;
+        private int indexMode;
         List<TouchManipulationBitmap> textCollection = new List<TouchManipulationBitmap>();
         List<TouchManipulationBitmap> stackCollection = new List<TouchManipulationBitmap>();
         Dictionary<long, TouchManipulationBitmap> textDictionary = new Dictionary<long, TouchManipulationBitmap>();
         private SKCanvas canvas;
 
 
-        public MainPage(List<string> playersNames)
+        public MainPage(List<string> playersNames, int nbPile, int indexMode)
         {
             this.playersNames = playersNames;
+            this.nbPile = nbPile;
+            this.indexMode = indexMode;
 
             InitializeComponent();
             NavigationPage.SetHasNavigationBar(this, false);
 
             EndTurnButton.Text = AppRessource.StrEndTurn;   // Trouver le moyen d'avoir du binding
 
-            viewmodel = new Main(playersNames);
+            viewmodel = new Main(playersNames, nbPile, indexMode);
 
             viewmodel.EndGame += OnEndGame;
 
@@ -242,7 +246,7 @@ namespace TheGameExtreme.view
 
         private void retry(object sender, EventArgs args)
         {
-            viewmodel = new Main(playersNames);
+            viewmodel = new Main(playersNames, nbPile, indexMode);
 
             viewmodel.EndGame += OnEndGame;
 

TheGameExtreme/viewmodel/Main.cs

@@ -6,6 +6,7 @@ using TheGameExtreme.model.card;
 using TheGameExtreme.model.deck;
 using TheGameExtreme.model.@event;
 using TheGameExtreme.model.gameActions.classic;
+using TheGameExtreme.model.gameActions.decimals;
 using TheGameExtreme.model.manager;
 using TheGameExtreme.model.piles;
 
@@ -51,11 +52,38 @@ namespace TheGameExtreme.viewmodel
         public List<Stack<CardVM>> listOrderedStacks = new List<Stack<CardVM>>();
 
 
-        public Main(List<string> playersNames)
+        public Main(List<string> playersNames, int nbPile, int indexMode)
         {
-            int nbPile = 4;
             playersNames.ForEach(name => players.Add(new PlayerVM(new Player(name))));
-            Parametreur parametreur = new Parametreur(new GameMode(new ClassicPiles(nbPile), new ClassicDeck()));
+            GameMode gameMode;
+            switch (indexMode)
+            {
+                case 0:
+                    gameMode = new GameMode(new ClassicPiles(nbPile), new ClassicDeck());
+                    break;
+                case 1:
+                    gameMode = new GameMode(new _50Range100Piles(nbPile), new _50Range100Deck());
+                    break;
+                case 2:
+                    gameMode = new GameMode(new DecimalPilesMoins5To5(nbPile), new DecimalDeck());
+                    break;
+                case 3:
+                    gameMode = new GameModeDecimal(new DecimalPilesMoins5To5(nbPile), new DizaineDeck());
+                    break;
+                case 4:
+                    gameMode = new GameMode(new DecimalPilesMoins5To5(nbPile), new CentaineDeck());
+                    break;
+                case 5:
+                    gameMode = new GameMode(new DecimalPilesMoins5To5(nbPile), new MilliemeDeck());
+                    break;
+                //case 6:
+                //    // Fraction
+                //    break;
+                default:
+                    gameMode = new GameMode(new ClassicPiles(nbPile), new ClassicDeck());
+                    break;
+            }
+            Parametreur parametreur = new Parametreur(gameMode);
             players.ForEach(player => parametreur.AddPlayer(player.View));
             gameManager = new SoloGameManager(parametreur);
 
@@ -101,6 +129,7 @@ namespace TheGameExtreme.viewmodel
 
         public void OnEndGame(object source, EventArgs args)
         {
+            Alert = gameManager.EndMessage;
             EndGame?.Invoke(source, args);
         }