Esempio n. 1
0
        public static void DeroulerPartie()
        {
            Console.WriteLine("\t\t\tPoke DOJO. \n\n\tUn jeu par Guillaume Grosse et Matéo Mahaut\n\t\tProjet Programmation Avancée\n\t\t\tENSC S6");
            Console.ReadKey();
            Console.Clear();
            Console.WriteLine("Vous vous apprétez à participer au plus grand tournoi de dresseurs qu'il soit !");

            // Permettre au joueur de choisir son nom
            Console.WriteLine("\t\tQuel est votre nom, jeune dresseur ?");
            Console.Write("\t\t");
            string nom   = Console.ReadLine();
            bool   choix = true;

            do
            {
                // Permettre au joueur de Choisir ses pokémons :
                int            depart    = 0;
                int            selection = 0;
                ConsoleKey     cki;
                List <Pokemon> sac   = new List <Pokemon>();
                Arene          arene = new Arene();

                do
                {
                    do
                    {
                        Console.Clear();
                        Console.WriteLine("Bonjour {0}, Avec quels Pokemons voulez vous jouer ?", nom);
                        int i = 0;
                        //Afficher la liste des pokémons
                        while (i <= 10)
                        {
                            if (i == selection)
                            {
                                //Coloration en fonction de si le Pokémon a déjà été selectionné
                                //On utilise la multiplication par 3 pour ne tomber que sur les pokémonsau premier stade d'évolution.
                                Console.ForegroundColor = !(sac.Contains(arene.PokeList1[3 * (depart + i)])) ? ConsoleColor.DarkGreen : ConsoleColor.DarkRed;
                                Console.Write(">>");
                                Console.WriteLine("\t" + arene.PokeList1[3 * (depart + i)].Nom + "\t" + arene.PokeList1[3 * (depart + i)].PV + " PV\t" + arene.PokeList1[3 * (depart + i)].PA + "PA\t" + "Elementaire " + arene.PokeList1[3 * (depart + i)]._types[arene.PokeList1[3 * (depart + i)].TypeElementaire]);
                                Console.ResetColor();
                            }
                            else
                            {
                                Console.WriteLine("\t" + arene.PokeList1[3 * (depart + i)]);
                            }
                            i++;
                        }

                        //Rappel des choix
                        Console.WriteLine();
                        Console.WriteLine("Voici les pokémons que vous avez sélectionnés :");
                        Console.ForegroundColor = ConsoleColor.DarkGreen;
                        foreach (Pokemon p in sac)
                        {
                            Console.WriteLine(p);
                        }
                        Console.ResetColor();
                        Console.WriteLine("\nAppuyer sur --> A <-- pour annuler la sélection");

                        cki = Console.ReadKey().Key;

                        //Prise en compte des entrées clavier
                        if (cki == ConsoleKey.UpArrow)
                        {
                            if (selection != 0)
                            {
                                selection = (selection - 1);
                            }
                            else if (depart != 0)
                            {
                                depart -= 1;
                            }
                        }

                        if (cki == ConsoleKey.DownArrow)
                        {
                            if (selection != 10)
                            {
                                selection = (selection + 1);
                            }
                            else if (depart != arene.PokeList1.Count / 3 - 11)
                            {
                                depart += 1;
                            }
                        }

                        //On verifie que le joueur a effectué une selection, une Annulation, et qu'il n'a pas essayé de sélectionner deux fois le même pokémon.
                    } while ((cki != ConsoleKey.Enter && cki != ConsoleKey.Spacebar && cki != ConsoleKey.A) || sac.Contains(arene.PokeList1[3 * (selection)]));

                    //Permettre une annulation
                    if (cki == ConsoleKey.A)
                    {
                        sac = new List <Pokemon>();
                    }
                    else
                    {
                        Pokemon poke = new Pokemon(arene.PokeList1[3 * (selection + depart)].Nom, arene.PokeList1[3 * (selection + depart)].PV, arene.PokeList1[3 * (selection + depart)].PA, arene.PokeList1[3 * (selection + depart)]._types[arene.PokeList1[3 * (selection + depart)].TypeElementaire][0]);
                        poke.NouvelleCapacite();
                        sac.Add(poke);
                    }
                } while (sac.Count < 3);
                //Créer le joueur personnalisé.
                Joueur j1 = new Joueur(nom, sac)
                {
                    EstHumain = true
                };
                // 1 : Faire apparaitre l'arbre des joueurs
                arene.Competiteurs[0] = j1;
                arene.Arbre[0][0]     = j1;

                Console.Clear();
                arene.AfficherArbreCompetition();
                Console.ReadKey();

                for (int roundNumber = 0; roundNumber < 4; roundNumber++)
                {
                    arene.Arbre.Add(new List <Joueur>());
                    for (int fightNumber = 0; fightNumber < arene.Arbre[roundNumber].Count; fightNumber += 2)
                    {
                        Joueur victorieux = JouerCombat(arene.Arbre[roundNumber][fightNumber], arene.Arbre[roundNumber][fightNumber + 1], arene);
                        Console.WriteLine("\n" + victorieux.Nom + " a gagné son combat :)");
                        arene.Arbre[roundNumber + 1].Add(victorieux);

                        Console.WriteLine("\n-- Presser une touche pour passer --");
                        Console.ReadKey();
                    }
                    //On remet tous les PV des gagnants à leur Maximum
                    foreach (Joueur j in arene.Arbre[roundNumber + 1])
                    {
                        foreach (Pokemon p in j.Sac)
                        {
                            p.MarqueurDegats = 0;
                            p.HistoriqueDegats.Clear();
                        }
                    }
                    //On affiche le nouvel Arbre des combats
                    arene.AfficherArbreCompetition();
                    Console.ReadKey();
                }
                Console.WriteLine("Le grand gagnant est... " + arene.Arbre[3][0]);

                do
                {
                    Console.Clear();
                    if (choix == true)
                    {
                        Console.WriteLine("  --> Rejouer <--   ou       Arrêter\n\n(utiliser les flèches du clavier pour sélectionner)");
                    }
                    else
                    {
                        Console.WriteLine("      Rejouer       ou   --> Arrêter <--\n\n(utiliser les flèches du clavier pour sélectionner)");
                    }
                    cki = Console.ReadKey().Key;


                    if (cki == ConsoleKey.LeftArrow || cki == ConsoleKey.RightArrow)
                    {
                        choix = !choix;
                    }
                } while (cki != ConsoleKey.Enter && cki != ConsoleKey.Spacebar);
                Console.Clear();
            } while (choix == true);
        }
Esempio n. 2
0
        public static bool JouerTour(Joueur j1, Joueur j2, Arene arene)
        {
            Random R = new Random();
            int    choix;

            if (j1.EstHumain || j2.EstHumain)
            {
                Console.WriteLine("C'est au tour de {0}, avec son pokémon {1} !", j1.Nom, j1.Actif.Nom);
                if (j1.EstHumain)
                {
                    AfficherCombat(j1, j2);
                    Console.WriteLine("{0} Attend vos instruction ...", j1.Actif.Nom);
                    //Dans le cas où le joueur est humain, on appelle l'affichage du menu pour savoir quel action le joueur veut effectuer
                    choix = Menu(j1);
                }
                //Par défaut un joueur non-humain attaque.
                else
                {
                    choix = 0;
                }
                if (j2.EstHumain)
                {
                    AfficherCombat(j2, j1);
                }
            }
            else
            {
                choix = 0;
            }

            //Si le joueur n'est pas humain, on le fait obligatoirement choisir d'attaquer.
            if (choix == 0)
            {
                //!!Attaque
                j2.Actif.RecevoirDegats(j1.Actif);
                if (j1.EstHumain || j2.EstHumain)
                {
                    Console.Clear();
                    //Attention, cette ligne de code ne prend pas en compte l'option que deux joueurs humains s'affrontent.
                    AfficherCombat(j1.EstHumain?j1:j2, j2.EstHumain ? j1 : j2);
                    Console.WriteLine("{0} Attaque {1}, qui perd {2} points de vie !", j1.Actif.Nom, j2.Actif.Nom, j2.Actif.HistoriqueDegats[j2.Actif.HistoriqueDegats.Count - 1]);
                    Console.ReadKey();
                }
                if (j2.Actif.MarqueurDegats > j2.Actif.PV)
                {
                    return(false);
                }
            }
            else if (choix == 1)
            {
                //!!Replis d'un pokémon
                if (j1.EstHumain)
                {
                    j1.Actif = ChoisirPokemonHumain(j1);
                    Console.WriteLine("{0} : {1} je te choisis !", j1.Nom, j1.Actif.Nom);
                }
            }
            else if (choix == 2)
            {
                //!!Capacité spéciale
                if (j1.EstHumain)
                {
                    ConsoleKey cki;
                    int        selection = 0;
                    do
                    {
                        Console.Clear();
                        if (j1.Actif.CapacitesSpeciales.Count != 0)
                        {
                            Console.WriteLine("Quelle Capacité spéciale voulez-vous utiliser ?");
                            for (int i = 0; i < j1.Actif.CapacitesSpeciales.Count; i++)
                            {
                                if (selection == i)
                                {
                                    Console.Write(">>");
                                }
                                Console.WriteLine("\t{0} - {1}", j1.Actif.CapacitesSpeciales[i]._nom, j1.Actif.CapacitesSpeciales[i]._alterations[0]);
                            }
                            cki = Console.ReadKey().Key;
                        }
                        //!! variante si aucune capa restante
                        else
                        {
                            Console.WriteLine("Votre pokémon est à court de capacités spéciales : il effectue une attaque");
                            cki = Console.ReadKey().Key;
                        }
                    } while (cki != ConsoleKey.Enter && cki != ConsoleKey.Spacebar);
                    Console.WriteLine("{0} Utilise {1}... Incroyable !");
                    j1.Actif.LancerCapacite(j2.Actif, selection);
                    Console.WriteLine("WIP : Cette option n'est pas encore disponible");
                }
            }

            else if (choix == 3)
            {
                //!!Fuite
                if (j1.EstHumain)
                {
                    Console.WriteLine("WIP : Cette option n'est pas encore disponible");
                }
            }
            return(true);
        }
Esempio n. 3
0
        public static Pokemon ChoisirPokemonHumain(Joueur j)
        {
            ConsoleKey cki;
            int        choix = 0;

            do
            {
                Console.Clear();
                Console.WriteLine("{0} ouvre son sac et regarde à l'interieur : \n", j.Nom);
                for (int i = 0; i < j.Sac.Count(); i++)
                {
                    if (choix == i)
                    {
                        if (j.Sac[choix].MarqueurDegats < j.Sac[choix].PV)
                        {
                            Console.Write(">>");
                        }
                        else
                        {
                            Console.Write("*|");
                        }
                    }

                    Console.Write("\t{0} :\t\t {1} PV, \t{2} PA", j.Sac[i].Nom, j.Sac[i].PV - j.Sac[i].MarqueurDegats, j.Sac[i].PA);
                    if (j.Sac[i].MarqueurDegats > j.Sac[i].PV)
                    {
                        Console.Write("\tKO");
                    }
                    Console.WriteLine();
                }
                //Expliquer à l'utilisateur pourquoi il ne peut pas sélectionner son Pokémon mort.
                if (j.Sac[choix].MarqueurDegats > j.Sac[choix].PV)
                {
                    Console.ForegroundColor = ConsoleColor.DarkRed;
                    Console.WriteLine("\nVous ne pouvez pas choisir {0}, il est KO :(", j.Sac[choix].Nom);
                    Console.ResetColor();
                }
                else
                {
                    Console.ForegroundColor = ConsoleColor.DarkGreen;
                    Console.WriteLine("\n{0} est prêt, et a très envie d'aider au combat !", j.Sac[choix].Nom);
                    Console.ResetColor();
                }
                //Attente puis enregistrement d'une entrée utilisateur
                cki = Console.ReadKey().Key;

                //Modification de l'option menu choisie en fonction de la saisie utilisateur
                if (cki == ConsoleKey.UpArrow)
                {
                    choix = (choix - 1) % 3;
                }
                if (cki == ConsoleKey.DownArrow)
                {
                    choix = (choix + 1) % 3;
                }

                if (choix < 0)
                {
                    choix = 3 + choix;
                }
            } while (cki != ConsoleKey.Enter && cki != ConsoleKey.Spacebar || j.Sac[choix].MarqueurDegats > j.Sac[choix].PV);
            Console.Clear();
            return(j.Sac[choix]);
        }
Esempio n. 4
0
        // Dans la version actuelle du jeu il ne peut y avoir qu'un joueur humain.
        // S'il y a un joueur humain, c'est j1
        public static Joueur JouerCombat(Joueur j1, Joueur j2, Arene arene)
        {
            Console.Clear();
            Random R = new Random();

            j2.Actif = j2.Sac[R.Next(3)];
            j1.Actif = j1.Sac[R.Next(3)];
            Joueur temp = j2;

            if (j1.EstHumain || j2.EstHumain)
            {
                //On affiche à gauche le nom du joueur et à droite celui de son adversaire
                Console.WriteLine("Bienvenue dans ce tournoi :\n\n\t  *****\n {0} vs {1}\n\t  *****\n\nJouons à Pile ou Face pour déterminer qui commence.", j1.Nom, j2.Nom);
                Console.ReadKey();

                // Si le joueur perd au pile ou face, son adversaire commence, on inverse donc l'ordre.
                if (!JouerPileOuFace())
                {
                    j2 = j1;
                    j1 = temp;
                }
                Console.WriteLine("Appuyez sur un touche, montez sur le Tatami, et choisissez un pokémon !");
                Console.ReadKey();

                if (j1.EstHumain)
                {
                    j1.Actif = ChoisirPokemonHumain(j1);
                    j2.Actif = j1.Sac[R.Next(3)];
                }
                else
                {
                    j1.Actif = j1.Sac[R.Next(3)];
                    j2.Actif = ChoisirPokemonHumain(j2);
                }

                Console.WriteLine("{0} : {1} je te choisis !\n", j1.Nom, j1.Actif.Nom);
                Console.WriteLine("{0} regarde dans son sac...\n{0} : {1} je te choisis !", j2.Nom, j2.Actif.Nom);
            }

            bool pokeVivant = true;

            //On entre dans les tours de partie. On ne peut sortir de cette boucle que lorsqu'un joueur gagne, car un return interrompt la fonction et donc la boucle.
            while (true)
            {
                //On joue un tour
                Console.Clear();
                pokeVivant = JouerTour(j1, j2, arene);
                //On verifie que le pokemon n'et pas mort pendant ce tours
                if (!pokeVivant)
                {
                    //si le poké qui l'a tué en est a son deuxième meurtre, on le fait évoluer. de toute façon on incrémente son KillCount
                    if (++j1.Actif.KillCount == 2)
                    {
                        EvoluerPokemon(j1.Actif, arene.PokeList1, j1.EstHumain);
                    }



                    //s'il est mort on regarde s'il reste un pokémon vivant dans le sac de son dresseur,
                    if (j1.EstHumain || j2.EstHumain)
                    {
                        Console.WriteLine("{0} est KO...", j1.Actif.Nom);
                    }

                    foreach (Pokemon p in j2.Sac)
                    {
                        if (p.MarqueurDegats < p.PV)
                        {
                            j2.Actif = p;
                        }
                    }

                    //On regarde si le pokemon a pu être remplacé
                    if (j2.Actif.MarqueurDegats > j2.Actif.PV)
                    {
                        //Si ce n'est pas le cas, l'autre joueur a gagné.
                        return(j1);
                    }
                    //Si le joueur est humain et qu'il n'a pas perdu, on le laisse choisir lui même le pokémon qu'il veut utiliser.
                    if (j2.EstHumain)
                    {
                        ChoisirPokemonHumain(j2);
                    }
                    if (j1.EstHumain || j2.EstHumain)
                    {
                        Console.WriteLine(" {0} Le remplace avec {1} !", j2.Nom, j2.Actif.Nom);
                        Console.ReadKey();
                    }

                    //On inverse ensuite les joueurs pour alterner le joueur qui défend et celui qui attaque.
                }
                temp = j2;
                j2   = j1;
                j1   = temp;
            }
        }