Beispiel #1
0
        public override void Attaque(Joueur joueur)
        {
            Degats = 0;
            int[] UneAttaque = new int[] { AttaqueRapide, AttaqueLourde, Bouclier, AttaqueMortel };
            int   Frappe     = new Random().Next(4);

            if (UneAttaque[Frappe] == AttaqueRapide)
            {
                DelegAsync.MethAsyncTexteM("Barzak crache du feu!");
                Degats = AttaqueRapide;
            }
            else if (UneAttaque[Frappe] == AttaqueLourde)
            {
                DelegAsync.MethAsyncTexteM("Barzak frappe avec sa hache!");
                Degats = AttaqueLourde;
            }
            else if (UneAttaque[Frappe] == Bouclier)
            {
                DelegAsync.MethAsyncTexteM("Barzak utilise son bouclier!");
                Degats = Bouclier;
            }
            else if (UneAttaque[Frappe] == AttaqueMortel)
            {
                DelegAsync.MethAsyncTexteM("Barzak déchaine toute sa puissance!");
                Degats = AttaqueMortel;
            }
        }
Beispiel #2
0
 public void EquipementLeger() // Arme petit monstre
 {
     Arme[arme] = new Random().Next(5);
     if (Arme[arme] == 3)
     {
         DelegAsync.MethAsyncTexteR("Génial, une nouvelle épée plus tranchante.");
     }
     else if (Arme[arme] == 4)
     {
         DelegAsync.MethAsyncTexteR("Super, un bouclier à pointe.");
     }
     else if (Arme[arme] == 2)
     {
         DelegAsync.MethAsyncTexteR("Un livre de magie, magnifique!");
     }
     else
     {
         DelegAsync.MethAsyncTexteR("Un Coffre! /n??? Vide? Qu'elle arnaque.");
     }
 }
Beispiel #3
0
        public override void Attaque(Joueur joueur)
        {
            Degats = 0;
            int[] UneAttaque = new int[] { AttaqueRapide, AttaqueLourde, Bouclier };
            int   Frappe     = new Random().Next(3);

            if (UneAttaque[Frappe] == AttaqueRapide)
            {
                DelegAsync.MethAsyncTexteM("Le fantôme lance une grimace terrifiante!");
                Degats = AttaqueRapide;
            }
            else if (UneAttaque[Frappe] == AttaqueLourde)
            {
                DelegAsync.MethAsyncTexteM("Le fantôme prépare un souffle de glace!");
                Degats = AttaqueLourde;
            }
            else if (UneAttaque[Frappe] == Bouclier)
            {
                DelegAsync.MethAsyncTexteM("Le fantôme utilise son boulet!");
                Degats = Bouclier;
            }
        }
Beispiel #4
0
        public override void Attaque(Joueur joueur)
        {
            Degats = 0;
            int[] UneAttaque = new int[] { AttaqueRapide, AttaqueLourde, Bouclier };
            int   Frappe     = new Random().Next(3);

            if (UneAttaque[Frappe] == AttaqueRapide)
            {
                DelegAsync.MethAsyncTexteM("Le gobelin attaque avec sa massue!");
                Degats = AttaqueRapide;
            }
            else if (UneAttaque[Frappe] == AttaqueLourde)
            {
                DelegAsync.MethAsyncTexteM("Le gobelin ce prépare a te sauter dessus!");
                Degats = AttaqueLourde;
            }
            else if (UneAttaque[Frappe] == Bouclier)
            {
                DelegAsync.MethAsyncTexteM("Le gobelin jete une pierre!");
                Degats = Bouclier;
            }
        }
Beispiel #5
0
        public override void Attaque(Joueur joueur)
        {
            Degats = 0;
            int[] UneAttaque = new int[] { AttaqueRapide, AttaqueLourde, Bouclier };
            int   Frappe     = new Random().Next(3);

            if (UneAttaque[Frappe] == AttaqueRapide)
            {
                DelegAsync.MethAsyncTexteM("Le troll donne un coup de pied!");
                Degats = AttaqueRapide;
            }
            else if (UneAttaque[Frappe] == AttaqueLourde)
            {
                DelegAsync.MethAsyncTexteM("Le troll frappe avec sa masse!");
                Degats = AttaqueLourde;
            }
            else if (UneAttaque[Frappe] == Bouclier)
            {
                DelegAsync.MethAsyncTexteM("Le troll concencre une grosse frappe!");
                Degats = Bouclier;
            }
        }
Beispiel #6
0
 public void EquipementLourd() // Arme gros monstre
 {
     Arme[arme] = new Random().Next(8);
     if (Arme[arme] == 2)
     {
         DelegAsync.MethAsyncTexteR("Qu'est ce que?? un puissant livre de magie, cool.");
     }
     else if (Arme[arme] == 3)
     {
         DelegAsync.MethAsyncTexteR("Ho joie, une hache.");
     }
     else if (Arme[arme] == 4)
     {
         DelegAsync.MethAsyncTexteR("Hmmm, un espadon.");
     }
     else if (Arme[arme] == 5)
     {
         DelegAsync.MethAsyncTexteR("Trop cool! Un bouclier d'acier.");
     }
     else
     {
         DelegAsync.MethAsyncTexteR("Un Coffre! /n??? Vide? Qu'elle arnaque.");
     }
 }
Beispiel #7
0
        public static async void CombattreTroll()
        {
            Joueur Vivi   = Joueur.Instance;
            Troll  Trolly = Troll.Instance;
            Query  query  = new Query();
            Page   page   = Page.Instance;
            bool   jeu    = true;

            DelegAsync.MethAsyncTexteJ("Combat: un troll.");
            await Task.Delay(2000);

            while (jeu)
            {
                while (Vivi.Vivant && Trolly.Vivant)
                {
                    Form1.PanelJeu.Invoke(new MethodInvoker(delegate { Vivi.LibereAttaque(); }));
                    MesBouttons.stop.WaitOne();
                    await Task.Delay(3000);

                    MesBouttons.stop.WaitOne();
                    Form1.PanelJeu.Invoke(new MethodInvoker(delegate { Vivi.BlockAttaque(); }));
                    Trolly.Attaque(Vivi);
                    if (Trolly.Degats == Trolly.AttaqueRapide && Vivi.Degats == Vivi.Bouclier || Trolly.Degats == Trolly.AttaqueLourde && Vivi.Degats == Vivi.AttaqueRapide || Trolly.Degats == Trolly.Bouclier && Vivi.Degats == Vivi.AttaqueLourde || Vivi.Degats == Vivi.Magie)
                    {
                        Trolly.SubirDegats(Vivi.Degats);
                        MesLabels.PVM.Invoke(new MethodInvoker(delegate { Trolly.UpMVie(); }));
                        if (Trolly.MVie > 0)
                        {
                            DelegAsync.MethAsyncTexteC("Ton attaque réussit.\nIl reste " +
                                                       Convert.ToString(Trolly.MVie) +
                                                       " point de vie au troll et tu en as encore " +
                                                       Convert.ToString(Vivi.Vie) +
                                                       " point de vies!");
                            await Task.Delay(3000);
                        }
                        else
                        {
                            DelegAsync.MethAsyncTexteJ("Le troll meurs!");
                            DelegAsync.MethAsyncTexteM("");
                        }
                    }
                    else if (Trolly.Degats == Trolly.AttaqueRapide && Vivi.Degats == Vivi.AttaqueLourde || Trolly.Degats == Trolly.AttaqueLourde && Vivi.Degats == Vivi.Bouclier || Trolly.Degats == Trolly.Bouclier && Vivi.Degats == Vivi.AttaqueRapide)
                    {
                        Vivi.SubitDegats(Trolly.Degats);
                        MesLabels.PV.Invoke(new MethodInvoker(delegate { Vivi.UpVie(); }));
                        if (Vivi.Vie > 0)
                        {
                            DelegAsync.MethAsyncTexteC("Le troll te touche.\nIl te reste " +
                                                       Convert.ToString(Vivi.Vie) +
                                                       " point de vie et le troll possède encore " +
                                                       Convert.ToString(Trolly.MVie) +
                                                       " point de vies!");
                            await Task.Delay(3000);
                        }
                        else
                        {
                            DelegAsync.MethAsyncTexteJ("Tu meurs!\nLe troll se délecte de ton cadavre!");
                            DelegAsync.MethAsyncTexteM("");
                        }
                    }
                    else
                    {
                        DelegAsync.MethAsyncTexteC("Le coup est contré!");
                        await Task.Delay(3000);
                    }

                    if (Vivi.Vivant && !Trolly.Vivant)
                    {
                        Vivi.Experience += 20;
                        Vivi.NiveauGagner();
                        Stuff stuff = Stuff.Lotterie;
                        stuff.EquipementLourd();
                        Vivi.PotionDeVie();
                        MesLabels.TexteCombat.Invoke(new MethodInvoker(delegate { Vivi.UpVie(); }));
                        query.SauvegardeDuJeu();
                        jeu = false;
                        Form1.PanelJeu.Invoke(new MethodInvoker(delegate { page.PageCombatFinit(); }));
                    }
                    else if (!Vivi.Vivant)
                    {
                        DelegAsync.MethAsyncTexteC("Perdu!!!");
                        jeu = false;
                    }
                }
            }
        }
Beispiel #8
0
        public static async void CombattreBossBarzak()
        {
            Joueur     Vivi   = Joueur.Instance;
            BossBarzak Barzak = BossBarzak.Instance;
            Query      query  = new Query();
            Page       page   = Page.Instance;
            bool       jeu    = true;


            DelegAsync.MethAsyncTexteJ("Combat: Barzak le roi des Orcs.");
            await Task.Delay(2000);

            while (jeu)
            {
                while (Vivi.Vivant && Barzak.Vivant)
                {
                    Form1.PanelJeu.Invoke(new MethodInvoker(delegate { Vivi.LibereAttaque(); }));
                    MesBouttons.stop.WaitOne();
                    await Task.Delay(3000);

                    MesBouttons.stop.WaitOne();
                    Form1.PanelJeu.Invoke(new MethodInvoker(delegate { Vivi.BlockAttaque(); }));
                    Barzak.Attaque(Vivi);
                    if (Barzak.Degats == Barzak.AttaqueRapide && Vivi.Degats == Vivi.Bouclier || Barzak.Degats == Barzak.AttaqueLourde && Vivi.Degats == Vivi.AttaqueRapide || Barzak.Degats == Barzak.Bouclier && Vivi.Degats == Vivi.AttaqueLourde || Vivi.Degats == Vivi.Magie)
                    {
                        Barzak.SubirDegats(Vivi.Degats);
                        MesLabels.PVM.Invoke(new MethodInvoker(delegate { Barzak.UpMVie(); }));
                        if (Barzak.MVie > 0)
                        {
                            DelegAsync.MethAsyncTexteC("Ton attaque réussit.\nIl reste " +
                                                       Convert.ToString(Barzak.MVie) +
                                                       " point de vie à Barzak et tu en as encore " +
                                                       Convert.ToString(Vivi.Vie) +
                                                       " point de vies!");
                            await Task.Delay(3000);
                        }
                        else
                        {
                            DelegAsync.MethAsyncTexteJ("Barzak meurs!\nBravo!!!   Tu viens de porter le coup de grace a Barzak!");
                            DelegAsync.MethAsyncTexteM("");
                        }
                    }
                    else if (Barzak.Degats == Barzak.AttaqueRapide && Vivi.Degats == Vivi.AttaqueLourde || Barzak.Degats == Barzak.AttaqueLourde && Vivi.Degats == Vivi.Bouclier || Barzak.Degats == Barzak.Bouclier && Vivi.Degats == Vivi.AttaqueRapide || Barzak.Degats == Barzak.AttaqueMortel && Vivi.Degats == Vivi.Magie || Barzak.Degats == Barzak.AttaqueMortel)
                    {
                        Vivi.SubitDegats(Barzak.Degats);
                        MesLabels.PV.Invoke(new MethodInvoker(delegate { Vivi.UpVie(); }));
                        if (Vivi.Vie > 0)
                        {
                            DelegAsync.MethAsyncTexteC("Barzak te touche.\nIl te reste " +
                                                       Convert.ToString(Vivi.Vie) +
                                                       " point de vie et Barzak possède encore " +
                                                       Convert.ToString(Barzak.MVie) +
                                                       " point de vies!");
                            await Task.Delay(3000);
                        }
                        else
                        {
                            DelegAsync.MethAsyncTexteJ("Tu meurs!\nBarzak plante ta tête sur une pique!");
                            DelegAsync.MethAsyncTexteM("");
                        }
                    }
                    else
                    {
                        DelegAsync.MethAsyncTexteC("Le coup est contré!");
                        await Task.Delay(3000);
                    }
                    if (Vivi.Vivant && !Barzak.Vivant)
                    {
                        DelegAsync.MethAsyncTexteC("Victoire!!!\n\n/FIN/");
                        query.SauvegardeDuJeu();
                        jeu = false;
                        Form1.PanelJeu.Invoke(new MethodInvoker(delegate { page.PageCombatFinit(); }));
                    }
                    else if (!Vivi.Vivant)
                    {
                        DelegAsync.MethAsyncTexteC("Perdu!!!");
                        jeu = false;
                    }
                }
            }
        }