Esempio n. 1
0
        public static void Melanger(List <Carte> MesCartes)
        {
            for (int v = 0; v < 1000; v++)
            {
                //un nombre aléatoire 0-51
                int index = MonRandom.Next(0, 51);

                //je vais chercher l'élément
                Carte ADeplacer = MesCartes[index];

                //je sauvegarde la première carte
                Carte Prems = MesCartes[0];

                //je place la carte à déplacer dans la première position
                MesCartes[0] = ADeplacer;

                //je place la premiére carte à la place de la carte déplacée
                MesCartes[index] = Prems;
            }
        }
Esempio n. 2
0
        private int JouerPli(List <Joueur> joueurs, ref Stack <Carte> pliActuelle, ref Stack <Carte> batailleActuelle)
        {
            int  indexGagnant = 0;
            bool jouer        = true;

            if ((joueurs[0].Main.Count() == 0))
            {
                jouer        = false;
                indexGagnant = 1;
            }
            else if (joueurs[1].Main.Count() == 0)
            {
                jouer        = false;
                indexGagnant = 0;
            }
            if (jouer)
            {
                foreach (Joueur joueur in joueurs)
                {
                    pliActuelle.Push(joueur.Main.Dequeue());
                }
                PlayedEventArgs args = new PlayedEventArgs();
                args.CarteJoueurs = new Stack <Carte>(pliActuelle.Reverse());
                OnPlayed(args);
                Carte meilleureCarte = null;
                int   index          = 0;
                foreach (Carte carte in pliActuelle)
                {
                    if (meilleureCarte != null)
                    {
                        if (meilleureCarte.CompareTo(carte) > 0)
                        {
                        }
                        else if (meilleureCarte.CompareTo(carte) == 0)
                        {
                            OnBataille(EventArgs.Empty);
                            foreach (Carte carte2 in pliActuelle)
                            {
                                batailleActuelle.Push(carte2);
                            }
                            pliActuelle.Clear();
                            foreach (Joueur joueur in joueurs)
                            {
                                batailleActuelle.Push(joueur.Main.Dequeue());
                            }
                            indexGagnant = JouerPli(joueurs, ref pliActuelle, ref batailleActuelle);// Bataille
                            break;
                        }
                        else
                        {
                            meilleureCarte = carte;
                            indexGagnant   = index;
                        }
                    }
                    else
                    {
                        meilleureCarte = carte;
                    }
                    index++;
                }
            }
            return(indexGagnant);
        }
Esempio n. 3
0
        public static void Jouer()
        {
            Console.WriteLine("================");
            Console.WriteLine("==Début de Jeu==");
            Console.WriteLine("================" + "\n");

            while (JoueurA.Count + TaGainA.Count > 0 && JoueurB.Count + TaGainB.Count > 0)
            {
                //on prend une carte de chaque tas

                Carte CA = JoueurA.Pop();
                Carte CB = JoueurB.Pop();

                Console.WriteLine("Carte JoueurA: {0}, {1}", CA.figure, CA.symbole);
                Console.WriteLine("Carte JoueurB: {0}, {1}", CB.figure, CB.symbole);

                if (CA.poids > CB.poids)
                {
                    Console.WriteLine("---------------JoueurA gagne la main");
                    //Joueur A gagne
                    TaGainA.Push(CB);
                    TaGainA.Push(CA);
                }
                else if (CA.poids < CB.poids)
                {
                    Console.WriteLine("---------------JoueurB gagne la main");
                    //Joueur B Gagne
                    TaGainB.Push(CA);
                    TaGainB.Push(CB);
                }

                //Bataille
                else
                {
                    Console.WriteLine("\n" + "=== Bataille ===");
                    Stack <Carte> CartesJouées1 = new Stack <Carte>();
                    Stack <Carte> CartesJouées2 = new Stack <Carte>();
                    Console.WriteLine("Carte JoueurA: {0}, {1}", CA.figure, CA.symbole);
                    Console.WriteLine("Carte JoueurB: {0}, {1}", CB.figure, CB.symbole);
                    CartesJouées1.Push(CA);
                    CartesJouées2.Push(CB);
                    Carte bataille1 = default(Carte);
                    Carte bataille2 = default(Carte);
                    while (bataille1.poids == bataille2.poids)
                    {
                        while (bataille1.poids == bataille2.poids && JoueurA.Count != 0 && JoueurB.Count != 0)
                        {
                            bataille1 = JoueurA.Pop();
                            CartesJouées1.Push(bataille1);
                            Console.WriteLine("Carte BatailleJoueurA: {0}, {1}", bataille1.figure, bataille1.symbole);
                            bataille2 = JoueurB.Pop();
                            CartesJouées2.Push(bataille2);
                            Console.WriteLine("Carte BatailleJoueurB: {0}, {1}", bataille2.figure, bataille2.symbole);

                            Test();
                        }

                        Console.WriteLine("==Fin Bataille==");
                        if (bataille1.poids > bataille2.poids)
                        {
                            Console.WriteLine("---------------JoueurA gagne la bataille" + "\n");
                            while (CartesJouées1.Count != 0)
                            {
                                Carte finbataille1 = CartesJouées1.Pop();
                                TaGainA.Push(finbataille1);
                            }
                            while (CartesJouées2.Count != 0)
                            {
                                Carte finbataille2 = CartesJouées2.Pop();
                                TaGainA.Push(finbataille2);
                            }
                        }
                        else if (bataille1.poids < bataille2.poids)
                        {
                            Console.WriteLine("---------------JoueurB gagne la bataille" + "\n");
                            while (CartesJouées1.Count != 0)
                            {
                                Carte finbataille1 = CartesJouées1.Pop();
                                TaGainB.Push(finbataille1);
                            }
                            while (CartesJouées2.Count != 0)
                            {
                                Carte finbataille2 = CartesJouées2.Pop();
                                TaGainB.Push(finbataille2);
                            }
                        }

                        Test();
                    }

                    Test();
                }

                Test();
            }


            Console.WriteLine("\n" + "================");
            Console.WriteLine("===Fin de Jeu ==");
            Console.WriteLine("================" + "\n");

            if (JoueurA.Count == 0)
            {
                Console.WriteLine("--------------------------JoueurA n'a plus des Cartes.");
                Console.WriteLine("--------------------------JoueurB a gagné!");
            }
            else
            {
                Console.WriteLine("--------------------------JoueurB n'a plus des cartes.");
                Console.WriteLine("--------------------------JoueurA a gagné!");
            }
        }