コード例 #1
0
ファイル: Joueur.cs プロジェクト: ClementRoelens/Dominion
        public List <Carte> Devoiler(int nombre)
        {
            List <Carte> cartesDevoilees = new List <Carte>();

            for (int i = 0; i < nombre; i++)
            {//Au cas où le joueur n'aurait plus de cartes dans son deck...
                if (this.Deck.Count == 0)
                {
                    this.MelangerLeDeck();
                }
                //Ensuite on ajoute la carte dans la liste et on la supprime du deck
                cartesDevoilees.Add(this.Deck[0]);
                this.Deck.RemoveAt(0);
            }
            //Ensuite on passe la List à la variable globale et on lance l'autre fenêtre
            AffichageCartesDevoilees.listCartesDevoilees = cartesDevoilees;
            AffichageCartesDevoilees.joueurDevoilant     = this;
            AffichageCartesDevoilees affichage = new AffichageCartesDevoilees();

            affichage.ShowDialog();

            return(cartesDevoilees);
        }
コード例 #2
0
        public void Effet()
        {
            Joueur        JoueurActuel = PartieForm.JoueurActuel;
            List <Joueur> ListeJoueurs = LancementForm.ListeJoueurs;

            //On gère d'abord les cas d'attaque
            if (this.Type.Contains("Attaque"))
            {
                //On commence par lancer un switch des différentes attaques pour donner à notre délégué la fonction correspondante

                switch (this.Nom)
                {
                //On va affecter à notre delegate Attaque la fonction correspondant à chaque attaque
                //Puisque celui-ci sera ensuite appelé dans une boucle pour chaque joueur, on considère l'action pour un seul joueur
                case "Noble brigand":
                {
                    attaque = delegate(Joueur cible)
                    {
                        //Le joueur doit révéler les deux premières cartes de son deck

                        List <Carte> liste = cible.Devoiler(2);
                        //Si aucune de ces deux cartes n'est un trésor, la cible reçoit un cuivre
                        if (liste.Find(x => x.Type.Contains("Trésor")) is null)
                        {
                            cible.Recevoir(PartieForm.mapListe.Find(x => x.carte.Nom == "Cuivre").carte);
                        }
                        //Si une de ces deux cartes est un argent ou un or, l'attaquant lui vole
                        else if ((liste.FindAll(x => (x.Nom == "Argent") || (x.Nom == "Or"))).Count > 0)
                        {
                            List <Carte> choix        = liste.FindAll(x => (x.Nom == "Argent") || (x.Nom == "Or"));
                            Carte        carteChoisie = new Carte();
                            //Si les deux cartes sont soit un or soit argent, on en fait choisir une à l'attaquant
                            if (choix.Count > 1)
                            {
                                carteChoisie = JoueurActuel.ChoisirUneCarte("Recevoir", choix, true);
                            }
                            //Sinon, on applique le traitement directement
                            else
                            {
                                carteChoisie = choix[0];
                            }
                            JoueurActuel.Defausse.Add(carteChoisie);
                            JoueurActuel.MAJInfos();
                            liste.Remove(carteChoisie);
                        }
                        //Dans tous les cas, la cible défausse ce qu'il a pioché, que l'attaquant lui ait volé une carte ou non
                        cible.Defausse.AddRange(liste);
                    };
                }
                break;

                case "Tortionnaire":
                {
                    attaque = delegate(Joueur cible)
                    {
                        //Le joueur va devoir choisir entre défausser 2 cartes ou recevoir une malédiction dans la main

                        ChoixForm.possibiliteChoisie = cible.ChoisirUnePossibilite("Défausser 2 cartes", "Recevoir une malédiction");
                        //Et on lance l'effet selon le choix du joueur
                        if (ChoixForm.possibiliteChoisie == "Défausser 2 cartes")
                        {
                            List <Carte> aDefausser = cible.ChoisirDesCartes("Défausser", cible.Main, 2, true);
                            cible.Defausser(aDefausser[0]);
                            cible.Defausser(aDefausser[1]);
                        }
                        else
                        {
                            cible.Recevoir(PartieForm.Malediction, "En main");
                        }
                    };
                }
                break;

                case "Sorcière":
                {
                    attaque = delegate(Joueur cible)
                    {
                        //Le joueur reçoit une malédiction

                        cible.Recevoir(PartieForm.Malediction);
                    };
                }
                break;
                }

                foreach (Joueur joueur in ListeJoueurs.FindAll(x => x != JoueurActuel))
                {
                    joueurSousAttaque = joueur;
                    //On réinitialise les booléens pour chaque joueur
                    continuerAttaque = true;
                    //Si la cible de l'attaque a une carte réaction (autre que l'Or des fous, qui ne réagit qu'à l'achat d'une province), il peut l'activer
                    if (!(joueur.Main.Find(x => (x.Type.Contains("Réaction")) && (x.Nom != "Or des fous")) is null))
                    {
                        Carte reaction = joueur.ChoisirUneCarte("Réaction", joueur.Main, false);
                        //Si le joueur choisit une carte, on lance l'effet
                        if (!(reaction is null))
                        {
                            reaction.Reagir();
                        }
                    }
                    if (continuerAttaque)
                    {
                        attaque(joueur);
                    }
                }
            }
            else
            {
                //Puis on code les effets
                switch (this.Nom)
                {
                case "Mascarade":
                {
                    //Chaque joueur doit passer une carte de sa main au joueur suivant, puis le joueur ayant joué la carte peut écarter une carte

                    List <Carte> carteEcartees = new List <Carte>();
                    //On fait donc une boucle de tous les joueurs, et on va choisir la carte, l'écarter de la main puis l'ajouter dans celle du joueur suivant
                    for (int i = 0, c = ListeJoueurs.Count; i < c; i++)
                    {
                        //On utilise la méthode pour choisir une carte dans la main
                        carteEcartees.Add(ListeJoueurs[i].ChoisirUneCarte("Ecarter", ListeJoueurs[i].Main, true));
                        //Puis on écarte
                        ListeJoueurs[i].Ecarter(carteEcartees[i]);
                    }
                    //Puis la carte est passée au joueur suivant (ou au premier quand le compteur atteint la limite du nombre de joueurs)
                    for (int i = 0, c = ListeJoueurs.Count; i < c; i++)
                    {
                        if (ListeJoueurs[i] == ListeJoueurs[ListeJoueurs.Count - 1])
                        {
                            ListeJoueurs[0].Main.Add(carteEcartees[i]);
                        }
                        else
                        {
                            ListeJoueurs[i + 1].Main.Add(carteEcartees[i]);
                        }
                    }
                    JoueurActuel.MAJMain();

                    //Puis le deuxième effet : le joueur qui joue peut écarter une carte de sa main
                    Carte carteEcartee = new Carte();
                    carteEcartee = JoueurActuel.ChoisirUneCarte("Ecarter", JoueurActuel.Main, false);
                    if (!(carteEcartee is null))
                    {
                        JoueurActuel.Ecarter(carteEcartee);
                    }
                }
                break;

                case "Evèque":
                {
                    //Ici on ajoute 1 pièce et 1 jeton, puis on fait écarter une carte et on gagne d'autres jetons selon son coût, et les autres peuvent écarter également

                    Carte carteEcartee = new Carte();
                    //On fait choisir la carte puis on l'écarte
                    carteEcartee = JoueurActuel.ChoisirUneCarte("Ecarter", JoueurActuel.Main, true);
                    JoueurActuel.Ecarter(carteEcartee);
                    //Puis on ajoute le bon nombre de jetons de victoire
                    double tempCout = carteEcartee.Cout / 2;
                    JoueurActuel.JetonVictoireDispo += (int)Math.Floor(tempCout);

                    //Puis on boucle sur les autres joueurs pour qu'ils écartent
                    for (int i = 0; i < ListeJoueurs.Count; i++)
                    {
                        carteEcartee = null;
                        //Gérer le cas d'annulation
                        carteEcartee = ListeJoueurs[i].ChoisirUneCarte("Ecarter", ListeJoueurs[i].Main, false);
                        if (!(carteEcartee is null))
                        {
                            ListeJoueurs[i].Ecarter(carteEcartee);
                        }
                    }
                }
                break;

                case "Bibliothèque":
                {
                    //Le joueur va piocher des cartes jusqu'à en avoir 7 et peut défausser les cartes action

                    //On crée une liste pour les cartes allant être défaussées
                    List <Carte> deCoté = new List <Carte>();
                    while (JoueurActuel.Main.Count < 7)
                    {
                        JoueurActuel.Piocher(1);
                        Carte carte = JoueurActuel.Main[JoueurActuel.Main.Count - 1];
                        if (carte.Type.Contains("Action"))
                        {
                            //On affiche la question.
                            DialogResult dr = MessageBox.Show($"Voulez-vous mettre {carte.Nom} de côté?", "Choix", MessageBoxButtons.YesNo);
                            //Si l'utilisateur répond oui, on ajoute la carte à la liste des cartes allant être défaussées
                            if (dr == DialogResult.Yes)
                            {
                                deCoté.Add(carte);
                            }
                        }
                    }
                    //Puis on défausse les cartes ayant été mises de côté
                    foreach (Carte carte in deCoté)
                    {
                        JoueurActuel.Defausser(carte);
                    }
                }
                break;

                case "Aventurier":
                {
                    //On va dévoiler des cartes jusqu'à trouver deux trésors. On défausse les autres

                    //On crée une List de cartes dévoilées
                    List <Carte> cartesDevoilees = new List <Carte>();
                    int          i = 0;
                    //Le compteur sera incrémenté par les trésors uniquement
                    while (i < 2)
                    {
                        //Pour ne pas lever d'erreur, on vérifie que le deck contient au moins une carte
                        if (JoueurActuel.Deck.Count > 0)
                        {
                            //Si la première carte du deck n'est pas un trésor, elle est ajoutée à la défausse
                            if (JoueurActuel.Deck[0].Type != "Trésor")
                            {
                                JoueurActuel.Defausse.Add(JoueurActuel.Deck[0]);
                            }
                            else
                            {
                                //Sinon, elle est ajoutée à la main et le compteur est incrémenté
                                JoueurActuel.Main.Add(JoueurActuel.Deck[0]);
                                i++;
                            }
                            //Dans tous les cas, la carte est ajoutée à la List des cartes dévoilées, puis supprimée du Deck
                            cartesDevoilees.Add(JoueurActuel.Deck[0]);
                            JoueurActuel.Deck.RemoveAt(0);
                        }
                        //Si le deck est vide, on le mélange avec la défausse
                        else
                        {
                            JoueurActuel.MelangerLeDeck();
                        }
                    }
                    //On affiche les cartes dévoilées
                    AffichageCartesDevoilees.listCartesDevoilees = cartesDevoilees;
                    AffichageCartesDevoilees form = new AffichageCartesDevoilees();
                    form.ShowDialog();
                    //Puis on met à jour les infos et la main
                }
                break;

                case "Agrandissement":
                {
                    //On écarte une carte de la main et reçoit une carte coûtant jusqu'à 3 de plus

                    //On fait d'abord choisir la carte à écarter dans la main
                    Carte carteEcartee = JoueurActuel.ChoisirUneCarte("Ecarter", JoueurActuel.Main, true);
                    JoueurActuel.Ecarter(carteEcartee);
                    MessageBox.Show("Choisissez une carte coûtant jusqu'à 3 de plus que la carte écartée");
                    //Puis on crée une liste de cartes coûtant au max 3 de plus que la carte écartée afin de la proposer en choix
                    List <Carte> piles = new List <Carte>();
                    //On crée une autre liste de Pile qu'on va trier pour afficher en premier les cartes les plus intéressantes
                    List <Pile> mapListe = new List <Pile>(PartieForm.mapListe);
                    mapListe = mapListe.OrderByDescending(x => x.carte.Cout).ToList();
                    foreach (Pile pile in mapListe)
                    {
                        //Les cartes proposées ne doivent pas coûter plus que 3 de plus que la carte écartée, mais elles doivent aussi encore être disponibles
                        if ((pile.nombre > 0) && (pile.carte.Cout <= carteEcartee.Cout + 3))
                        {
                            piles.Add(pile.carte);
                        }
                    }
                    //On choisit la carte et on la reçoit
                    Carte carteRecue = JoueurActuel.ChoisirUneCarte("Recevoir", piles, true);
                    JoueurActuel.Recevoir(carteRecue);
                }
                break;

                case "Or des fous":
                {
                    //Le trésor vaut 1 si c'est le premier joué, 4 si au moins un Or des fous a été joué précédemment

                    JoueurActuel.MonnaieDispo = ((JoueurActuel.Main.Find(x => (x.Nom == "Or des fous") && (x.EnJeu) && (x != this))) is null) ? JoueurActuel.MonnaieDispo + 1 : JoueurActuel.MonnaieDispo + 4;
                }
                break;

                case "Rénovation":
                {
                    //On écarte une carte de la main et on reçoit une carte coûtant jusqu'à 2 de plus
                    //(il s'agit ni plus ni moins que de l'effet d'agrandissement avec 2 à la place de 3)

                    //On fait d'abord choisir la carte à écarter dans la main
                    Carte carteEcartee = JoueurActuel.ChoisirUneCarte("Ecarter", JoueurActuel.Main, true);
                    JoueurActuel.Ecarter(carteEcartee);
                    MessageBox.Show("Choisissez une carte coûtant jusqu'à 2 de plus que la carte écartée");
                    //Puis on crée une liste de cartes coûtant au max 2 de plus que la carte écartée afin de la proposer en choix
                    List <Carte> piles = new List <Carte>();
                    //On crée une autre liste de Pile qu'on va trier pour afficher en premier les cartes les plus intéressantes
                    List <Pile> mapListe = new List <Pile>(PartieForm.mapListe);
                    mapListe = mapListe.OrderByDescending(x => x.carte.Cout).ToList();
                    foreach (Pile pile in mapListe)
                    {
                        //Les cartes proposées ne doivent pas coûter plus que 3 de plus que la carte écartée, mais elles doivent aussi encore être disponibles
                        if ((pile.nombre > 0) && (pile.carte.Cout <= carteEcartee.Cout + 2))
                        {
                            piles.Add(pile.carte);
                        }
                    }
                    //On choisit la carte et on la reçoit
                    Carte carteRecue = JoueurActuel.ChoisirUneCarte("Recevoir", piles, true);
                    JoueurActuel.Recevoir(carteRecue);
                }
                break;

                case "Village agricole":
                {
                    //Le joueur dévoile des cartes jusqu'à tomber sur une Action ou un Trésor

                    Carte carte = new Carte();

                    int i = 0;
                    do
                    {
                        carte = JoueurActuel.Deck[i];
                        i++;
                    }while (!carte.Type.Contains("Action") && !carte.Type.Contains("Trésor"));
                    //Et on lance la fonction pour dévoiler le nombre de cartes approprié
                    List <Carte> cartesDevoilees = JoueurActuel.Devoiler(i);

                    //On sort la dernière carte de la List, on l'ajoute à la main, et on met les autres dans le défausse
                    JoueurActuel.Main.Add(cartesDevoilees.Last());
                    cartesDevoilees.RemoveAt(cartesDevoilees.Count - 1);
                    JoueurActuel.Defausse.AddRange(cartesDevoilees);
                }
                break;

                case "Mine":
                {
                    //Le joueur écarte un Trésor et en reçoit une dans la main coûtant jusqu'à 3 de plus
                    //Encore un code ressemblant à Agrandissement et Rénovation

                    //On fait choisir une carte Trésor et on l'écarte
                    Carte carteEcartee = JoueurActuel.ChoisirUneCarte("Ecarter", JoueurActuel.Main.FindAll(x => x.Type.Contains("Trésor")), true);
                    JoueurActuel.Ecarter(carteEcartee);
                    MessageBox.Show("Choisissez un Trésor coûtant jusqu'à 3 de plus que le Trésor écarté");
                    //Puis on crée une liste de trésors coûtant au max 3 de plus que le trésor écarté afin de la proposer en choix
                    List <Carte> piles = new List <Carte>();
                    //On crée une autre liste de Pile qu'on va trier pour afficher en premier les cartes les plus intéressantes
                    List <Pile> mapListe = new List <Pile>(PartieForm.mapListe);
                    mapListe = mapListe.OrderByDescending(x => x.carte.Cout).ToList();
                    foreach (Pile pile in mapListe)
                    {
                        //Les cartes proposées ne doivent pas coûter plus que 3 de plus que la carte écartée, mais elles doivent aussi encore être disponibles
                        if ((pile.nombre > 0) && (pile.carte.Cout <= carteEcartee.Cout + 3) && (pile.carte.Type.Contains("Trésor")))
                        {
                            piles.Add(pile.carte);
                        }
                    }
                    //On choisit la carte et on la reçoit
                    Carte carteRecue = JoueurActuel.ChoisirUneCarte("Recevoir", piles, true);
                    JoueurActuel.Recevoir(carteRecue, "En main");
                }
                break;

                case "Marchand d'épices":
                {
                    //Le joueur choisit une des possibiltiés en échange de l'écartement d'une carte de sa main

                    string choix         = JoueurActuel.ChoisirUnePossibilite("+2 cartes +1 action", "+1 achat +2 monnaie");
                    Carte  carteAecarter = JoueurActuel.ChoisirUneCarte("Ecarter", JoueurActuel.Main, true);
                    JoueurActuel.Ecarter(carteAecarter);
                    if (choix == "+2 cartes +1 action")
                    {
                        JoueurActuel.Piocher(2);
                        JoueurActuel.ActionDispo++;
                    }
                    else
                    {
                        JoueurActuel.AchatDispo++;
                        JoueurActuel.MonnaieDispo += 2;
                    }
                }
                break;

                case "Ambassade":
                {
                    //Après avoir pioché ses 5 cartes, le joueur doit en défausser 3.

                    List <Carte> aDefausser = JoueurActuel.ChoisirDesCartes("Défausser", JoueurActuel.Main, 3, true);
                    foreach (Carte carte in aDefausser)
                    {
                        JoueurActuel.Defausser(carte);
                    }
                }
                break;

                case "Mandarin":
                {
                    //Le joueur choisit une carte de sa main qu'il place sur son deck

                    Carte aDeplacer = JoueurActuel.ChoisirUneCarte("Deck", JoueurActuel.Main.FindAll(x => x.EnJeu == false), true);
                    JoueurActuel.Deck.Insert(0, aDeplacer);
                    JoueurActuel.Main.Remove(aDeplacer);
                }
                break;
                }
            }
        }