public void Recevoir(Carte cible, string zone = "Défausse")
{
//On crée une nouvelle instance de la carte qu'on va ajouter à la défausse
Carte tempCarte = (Carte)cible.Clone();
//Si la cible est un campement nomade, elle est forcément reçue sur le deck
if (cible.Nom == "Campement nomade")
{
zone = "Deck";
}
//On ajoute la carte à la zone spécifiée et on met à jour les infos
switch (zone)
{
case "En main":
this.Main.Add(tempCarte);
if (this == PartieForm.JoueurActuel)
{
this.MAJMain();
this.MAJInfos();
}
break;
case "Défausse":
this.Defausse.Add(tempCarte);
//Bien entendu on met à jour l'affichage de la défausse si le joueur ayant reçu la carte est le joueur actuel
if (this == PartieForm.JoueurActuel)
{
PartieForm.defaussePB.ImageLocation = cible.Image;
PartieForm.defausseTB.Text = $"Défausse : {this.Defausse.Count.ToString()}";
}
break;
case "Deck":
this.Deck.Insert(0, cible);
PartieForm.deckTB.Text = $"Deck : {this.Deck.Count.ToString()}";
break;
}
//Et on désincrémente le nombre de cartes dans la pile si la carte n'est pas une Malédiction (car elle n'est pas dans les piles)
if (cible.Nom != "Malédiction")
{
//En cherchant la carte avant-tout...
List <Pile> mapListe = PartieForm.mapListe;
bool flag = false;
int i = 0;
while (!flag)
{
if (mapListe[i].carte.Nom == cible.Nom)
{
flag = true;
}
else
{
i++;
}
}
mapListe[i].nombre--;
//Et on lance la vérification pour savoir si on achève la partie
//La partie s'achève quand : une des piles Colonie ou Province est vide, ou quand 3 piles au total sont vides
if (mapListe[i].nombre == 0)
{
//Tout d'abord, si la pile de la carte venant d'être reçue tombe à 0, alors on efface l'image, on désactive le PictureBox et on incrémente le compteur de piles vides
mapListe[i].carte.PictureBox.ImageLocation = @"C:\Users\ohne6\Desktop\Dominion\Images\dosDeCarte.jpg";
mapListe[i].carte.PictureBox.Enabled = false;
PartieForm.nbPileVide++;
//Et ensuite on teste si la partie s'arrête
if ((mapListe[i].carte.Nom == "Province") || (mapListe[i].carte.Nom == "Colonie") || (PartieForm.nbPileVide == 3))
{
FinDePartie finDePartie = new FinDePartie();
finDePartie.ShowDialog();
}
}
Console.WriteLine($"{this.Nom} reçoit {cible.Nom}");
}
//Certaines cartes déclenchent des effets spécifiques quand elles sont reçues
switch (tempCarte.Nom)
{
case "Province":
{
//Si quelqu'un reçoit une Province, un autre joueur peut activer Or des fous
foreach (Joueur joueur in LancementForm.ListeJoueurs.FindAll(x => x != this))
{
List <Carte> orsDesFous = new List <Carte>();
orsDesFous.AddRange(joueur.Main.FindAll(x => x.Nom == "Or des fous"));
if (orsDesFous.Count > 0)
{
PartieForm.tempJoueur = LancementForm.ListeJoueurs.Find(x => x != this);
foreach (Carte carte in orsDesFous)
{
carte.Reagir();
}
}
}
}
break;
case "Ambassade":
{
//Quand un joueur reçoit une Ambassade, les autres reçoivent un argent
foreach (Joueur joueur in LancementForm.ListeJoueurs.FindAll(x => x != this))
{
joueur.Recevoir(PartieForm.mapListe.Find(x => x.carte.Nom == "Argent").carte);
}
}
break;
case "Mandarin":
{
//Le joueur va placer tous ses trésors en jeu sur son deck, dans l'ordre qu'il souhaite
//On commence par créer la liste des trésors en jeu
List <Carte> aPlacer = this.Main.FindAll(x => (x.Type.Contains("Trésor") && (x.EnJeu)));
MessageBox.Show("Vous allez placer vos trésors en jeu sur votre deck, un par un.");
//Puis on demande de placer un trésor sur le deck jusqu'à qu'ils soient tous lacés
for (int i = 0, c = aPlacer.Count - 1; i < c; i++)
{
Carte carteAplacer = this.ChoisirUneCarte("Deck", aPlacer, true);
carteAplacer.EnJeu = false;
this.Deck.Insert(0, carteAplacer);
this.Main.Remove(carteAplacer);
aPlacer.Remove(carteAplacer);
}
//On place la dernière carte automatiquement, puisqu'il n'y a plus de choix à faire
aPlacer[0].EnJeu = false;
this.Deck.Insert(0, aPlacer[0]);
this.Main.Remove(aPlacer[0]);
this.MAJMain();
}
break;
}
}
private void Button1_Click_1(object sender, EventArgs e)
{
Carte test = LancementForm.ListeCartesAction.Find(x => x.Nom == "Noble brigand");
Joueur autre = ListeJoueurs.Find(x => x != JoueurActuel);
autre.Main.Add(new Carte("Douves", @"C:\Users\ohne6\source\repos\Dominion\Dominion\Images\2Douves.jpg", 2, "Réaction", "effet", 0, 0, 0, 0, 0, 0));
//Carte ordesfous = new Carte("Or des fous", @"C:\Users\ohne6\source\repos\Dominion\Dominion\Images\Acoder\5Tortionnaire.jpg", 6, "Trésor", "gfreg", 0, 0, 0, 0, 0, 0);
//JoueurActuel.Main.Add(ordesfous);
//ordesfous.EnJeu = true;
test.Effet();
////Ce booléen va déterminer si oui ou non on saute l'étape de sélection de la monnaie
//bool continuer = false;
////On vérifie ensuite si le joueur a au moins un achat dispo
//if (JoueurActuel.AchatDispo < 1)
//{ MessageBox.Show("Vous n'avez plus d'achat disponible"); }
////Si oui, on lance la procédure d'achat avec les différentes vérifications
////Si non, l'achat va pas être validé puisque continuer == false
//else
//{
// //On teste si le joueur n'a pas déjà assez de monnaie disponible. Si oui, continuer = true et on va pouvoir valider l'achat directement
// if (JoueurActuel.MonnaieDispo >= test.Cout)
// { continuer = true; }
// //Si non, notre booléen va rester à faux et on va donc devoir demander au joueur de sélectionner des cartes Trésor
// else
// {
// //On va appeler une fonction ouvrant notre formulaire de choix, et on doit donc lui passer la carte devant être achetée, pour avoir son coût
// carteAacheter = test;
// //La fonction retourne une liste de carte, on crée donc une nouvelle List
// List<Carte> tresorsSelectionnes = JoueurActuel.ChoisirDesCartes("Achat", JoueurActuel.Main, int.MaxValue, false);
// //Ensuite, on continue l'action seulement si le formulaire a bien été validé (si non, continuer == false et donc l'achat ne sera pas finalisé)
// if (ChoixForm.estValide)
// {
// //Vérification nécessaire pour la carte Grand marché
// bool grandMarche = true;
// if (carteAacheter.Nom == "Grand marché")
// {
// if (!(tresorsSelectionnes.Find(x => x.Nom == "Cuivre") is null))
// { grandMarche = false; }
// if (grandMarche)
// {
// foreach (Carte carte in JoueurActuel.Main)
// {
// if (carte.EnJeu && (carte.Nom == "Cuivre"))
// {
// grandMarche = false;
// break;
// }
// }
// }
// }
// if (!grandMarche)
// {
// //La carte ne peut être achetée si des cuivres sont en jeu.
// //Si on en détecte un, on sort de la fonction d'achat
// MessageBox.Show("Vous ne pouvez pas acheter cette carte avec des cuivres en jeu.");
// }
// else
// {
// //On vérifie d'abord si le joueur a bien sélectionné assez de monnaie
// int monnaieSelectionnee = 0;
// foreach (Carte carte in tresorsSelectionnes)
// { monnaieSelectionnee += carte.MonnaieDonnee; }
// if ((monnaieSelectionnee + JoueurActuel.MonnaieDispo) < test.Cout)
// {
// //Si ce n'est pas le cas, on le dit et on arrête l'action, sans valider l'achat, sans mettre en jeu, toujours car continuer == false
// MessageBox.Show("Vous n'avez pas assez de monnaie");
// }
// else
// {
// //Si oui, on refait une boucle pour trouver les PictureBox correspondantes et les déplacer vers le bas, ainsi que pour activer les cartes
// foreach (Carte carte in tresorsSelectionnes)
// {
// carte.EnJeu = true;
// //On doit chercher une image correspondante dans la main
// for (int j = 0, c = JoueurActuel.Main.Count; j < c; j++)
// {
// //On cherche l'image correspondante oui, mais elle ne doit pas déjà avoir été activée
// if ((listPictureBoxMain[j].ImageLocation == carte.Image) && (listPictureBoxMain[j].Anchor != AnchorStyles.Bottom))
// {
// listPictureBoxMain[j].Anchor = AnchorStyles.Bottom;
// //On utilise un break pour sortir de la boucle dès qu'une carte a été sélectionnée, afin de ne bien décaler qu'une PictureBox par carte...
// break;
// }
// }
// }
// //On ajoute le total de monnaie des cartes activées à la monnaie dispo du joueur
// JoueurActuel.MonnaieDispo += monnaieSelectionnee;
// //Et on peut valider le booléen pour continuer l'achat
// continuer = true;
// }
// }
// }
// if (continuer)
// {
// //On crée une nouvelle instance de la carte qu'on va ajouter à la défausse
// Carte tempCarte = (Carte)test.Clone();
// JoueurActuel.Defausse.Add(tempCarte);
// //Bien entendu on met à jour l'affichage de la défausse
// defausseImage.ImageLocation = test.Image;
// defausseLabel.Text = "Défausse : " + JoueurActuel.Defausse.Count.ToString();
// //Et bien sûr on désincrémente également le nombre d'achats et la monnaie disponibles et on met à jour l'affichage
// JoueurActuel.AchatDispo--;
// JoueurActuel.MonnaieDispo -= test.Cout;
// MAJInfos();
// }
// }
//}
}
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;
}
}
}
private void PartieForm_Load(object sender, EventArgs e)
{
//On commence par constituer la map du jeu en faisant une sélection de 10 cartes Action et en chargeant toutes les cartes
#region Constitution de la map
//Une pile est composée d'une carte, du nombre de cartes composant la pile, et de la PictureBox comportant l'image de la Carte
//Cela est nécessaire car l'utilisateur n'interagira qu'avec les images, et donc les PictureBox
//On commence par faire une List des PictureBox pour ensuite pouvoir les ajouter à nos Pile
List <PictureBox> listPicturebox = new List <PictureBox>();
listPicturebox.Add(pictureBox1);
listPicturebox.Add(pictureBox2);
listPicturebox.Add(pictureBox3);
listPicturebox.Add(pictureBox4);
listPicturebox.Add(pictureBox5);
listPicturebox.Add(pictureBox6);
listPicturebox.Add(pictureBox7);
listPicturebox.Add(pictureBox8);
listPicturebox.Add(pictureBox9);
listPicturebox.Add(pictureBox10);
listPicturebox.Add(pictureBox11);
listPicturebox.Add(pictureBox12);
listPicturebox.Add(pictureBox13);
listPicturebox.Add(pictureBox14);
listPicturebox.Add(pictureBox15);
listPicturebox.Add(pictureBox16);
listPicturebox.Add(pictureBox17);
listPicturebox.Add(pictureBox18);
//On va ensuite ajouter les Carte à chaque Pile
//On commence donc par ajouter les cartes de base, en traitant à part la carte Malédiction
//On utilise un compteur implémenté à chaque fois qu'une carte est ajoutée à la map
//Ainsi on sait quel PictureBox ajouter dans notre Pile
int i = 0;
foreach (Carte carte in LancementForm.ListeCartesDeBase)
{
if (carte.Nom == "Malédiction")
{
Malediction = carte;
PileMalediction = new Pile(Malediction);
}
else
{
Pile pile = new Pile(carte);
i++;
mapListe.Add(pile);
}
}
//Maintenant que nous avons ajouté toutes les cartes Trésor et Victoire , on va mélanger la List des Actions et ajouter les 10 premières.
//Pour ce faire, on va rajouter aléatoirement une carte de notre première List à une List temporaire de cartes Action (pour ensuite les trier)
List <Carte> tempActions = new List <Carte>();
for (int j = 0; j < 10; j++)
{
int index = rand.Next(0, LancementForm.ListeCartesAction.Count);
tempActions.Add(LancementForm.ListeCartesAction[index]);
LancementForm.ListeCartesAction.RemoveAt(index);
}
//Une fois nos 10 cartes sélectionnées, on trie par Coût les cartes Action sélectionnées
tempActions.Sort(delegate(Carte a1, Carte a2) { return(a1.Cout - a2.Cout); });
//Puis on les ajoute à la mapListe
for (int j = 0; j < 10; j++)
{
Pile pile = new Pile(tempActions[j]);
mapListe.Add(pile);
}
//On remplit les PictureBox
i = 0;
foreach (Pile pile in mapListe)
{
pile.carte.PictureBox = listPicturebox[i];
pile.carte.PictureBox.ImageLocation = pile.carte.Image;
pile.carte.PictureBox.Dock = DockStyle.Fill;
pile.carte.PictureBox.SizeMode = PictureBoxSizeMode.StretchImage;
i++;
}
#endregion
//On constitue les decks, les mélange et pioche la première main pour chaque joueur
#region Initialisation de la partie
//On commence par faire une List des PictureBox qui seront utilisées pour afficher les cartes de la main
listPictureBoxMain.Add(carteMain1);
listPictureBoxMain.Add(carteMain2);
listPictureBoxMain.Add(carteMain3);
listPictureBoxMain.Add(carteMain4);
listPictureBoxMain.Add(carteMain5);
listPictureBoxMain.Add(carteMain6);
listPictureBoxMain.Add(carteMain7);
listPictureBoxMain.Add(carteMain8);
listPictureBoxMain.Add(carteMain9);
listPictureBoxMain.Add(carteMain10);
listPictureBoxMain.Add(carteMain11);
listPictureBoxMain.Add(carteMain12);
listPictureBoxMain.Add(carteMain13);
listPictureBoxMain.Add(carteMain14);
listPictureBoxMain.Add(carteMain15);
listPictureBoxMain.Add(carteMain16);
listPictureBoxMain.Add(carteMain17);
listPictureBoxMain.Add(carteMain18);
listPictureBoxMain.Add(carteMain19);
listPictureBoxMain.Add(carteMain20);
listPictureBoxMain.Add(carteMain21);
listPictureBoxMain.Add(carteMain22);
listPictureBoxMain.Add(carteMain23);
listPictureBoxMain.Add(carteMain24);
listPictureBoxMain.Add(carteMain25);
listPictureBoxMain.Add(carteMain26);
listPictureBoxMain.Add(carteMain27);
listPictureBoxMain.Add(carteMain28);
listPictureBoxMain.Add(carteMain29);
listPictureBoxMain.Add(carteMain30);
listPictureBoxMain.Add(carteMain31);
listPictureBoxMain.Add(carteMain32);
//Puis on lance les méthodes correspondantes
foreach (Joueur joueur in ListeJoueurs)
{
joueur.MelangerLeDeck();
joueur.Piocher(5);
}
//Ensuite, donne aléatoirement la main
int main = rand.Next(0, ListeJoueurs.Count);
JoueurActuel = ListeJoueurs[main];
//Enfin, avant de commencer, on affecte nos variables globales
deckPB = deckImage;
deckTB = deckLabel;
defaussePB = defausseImage;
defausseTB = defausseLabel;
tourTB = tourLabel;
achatDispoTB = achatDispoTextBox;
actionDispoTB = actionDispoTextBox;
monnaieDispoTB = monnaieDispoTextBox;
monnaieTotaleTB = monnaieTotaleTextBox;
jetonsTB = jetonsTextBox;
#endregion
//Les tours vont se succéder jusqu'à ce qu'un événement déclenche la fin de la partie
NouveauTour();
}
private void Form1_Load(object sender, EventArgs e)
{
//On va d'abord créer une instance de chaque carte
//Configuration et connexion
//string connectPath = @".\SQLEXPRESS01";
string path = Path.GetFullPath(Path.Combine(Application.StartupPath, @"..\.."));
SqlConnection conn = new SqlConnection(@"Data Source=(LocalDB)\MSSQLLocalDB;AttachDbFilename=" + path + @"\BD_cartes.mdf;Integrated Security=True");
SqlCommand cmd;
string sSQL = "SELECT* FROM [dbo].[Cartes_de_base]";
cmd = new SqlCommand(sSQL, conn);
cmd.CommandType = CommandType.Text;
SqlDataReader dataRead;
conn.Open();
dataRead = cmd.ExecuteReader();
//On initialise une carte temporaire
Carte tempCarte;
//Elle va recevoir toutes les caractéristiques enregistrées dans la BD
//Puis elle sera ajoutée à la et on passe à la carte suivante
while (dataRead.Read())
{
tempCarte = new Carte
(dataRead["Nom"].ToString(),
path + @"\Images\" + dataRead["Image"].ToString(),
int.Parse(dataRead["Cout"].ToString()), dataRead["Type"].ToString(),
dataRead["Effet"].ToString(),
int.Parse(dataRead["MonnaieDonne"].ToString()),
int.Parse(dataRead["CarteDonnee"].ToString()),
int.Parse(dataRead["ActionDonnee"].ToString()),
int.Parse(dataRead["AchatDonne"].ToString()),
int.Parse(dataRead["JetonPointDonne"].ToString()),
int.Parse(dataRead["PointDonne"].ToString()));
ListeCartesDeBase.Add(tempCarte);
}
dataRead.Close();
//Et on fait la même chose pour les cartes Action
sSQL = "SELECT* FROM [dbo].[Cartes_action]";
cmd = new SqlCommand(sSQL, conn);
dataRead = cmd.ExecuteReader();
while (dataRead.Read())
{
tempCarte = new Carte
(dataRead["Nom"].ToString(),
path + @"\Images\" + dataRead["Image"].ToString(),
int.Parse(dataRead["Cout"].ToString()), dataRead["Type"].ToString(),
dataRead["Effet"].ToString(),
int.Parse(dataRead["MonnaieDonne"].ToString()),
int.Parse(dataRead["CarteDonnee"].ToString()),
int.Parse(dataRead["ActionDonnee"].ToString()),
int.Parse(dataRead["AchatDonne"].ToString()),
int.Parse(dataRead["JetonPointDonne"].ToString()),
int.Parse(dataRead["PointDonne"].ToString()));
ListeCartesAction.Add(tempCarte);
}
//Et on ferme la connexion
dataRead.Close();
conn.Close();
}