/// <summary> /// S'exécute lorsque l'on clique sur le bouton « Bleu ». /// </summary> /// <param name="sender">Objet appelant</param> /// <param name="e">Arguments</param> private void btnBleu_Click(object sender, RoutedEventArgs e) { GestionnaireEcransJeu.ChangerEcran("Placement des pieces", new Dictionary <string, ParametresConstruction> { { "Couleur joueurs", new ParametresCouleurJoueurs(Couleur.Bleu) } }); }
/// <summary> /// S'exécute lorsque l'on clique sur le bouton « Jouer ». /// </summary> /// <param name="sender">Objet appelant</param> /// <param name="e">Arguments</param> private void btnJouer_Click(object sender, RoutedEventArgs e) { GestionnaireEcransJeu.ChangerEcran( "Partie", new Dictionary <string, ParametresConstruction> { { "Pieces", new ParametresPiecesJoueur(pieces, GrilleJeu.TAILLE_GRILLE_JEU, HAUTEUR_GRILLE_DISPONIBLE) }, { "Couleur joueurs", ParametresCouleursJoueurs } } ); }
/// <summary> /// Fenêtre principale, contient une grille où on affiche les contrôle /// /// Bonus : le système de sélection des pièces. /// Je ne sais pas si cela se qualifie comme fonctionnalité bonus, car ce n'est pas tant une fonctionnalité pour utilisateur /// (il fallait de toute façon qu'il puisse choisir les pièces). Cependant, je considère que c'est une fonctionnalité /// supplémentaire quand même; c'est plutôt une fonctionnalité au niveau des mechanismes qui sont employés: /// • La classe « SelectionneurPieces » est un contrôleur auquel on peut demander de nous donner une pièce ou d'en /// reprendre une. /// • Pour chaque type de pièce, il y a un générateur de pièces qui gère lui-même le nombre de pièces /// qu'on peut encore placer. /// • La structure de générateurs est une factory, ce qui permet de traiter toutes les pièces de la même façon, /// en évitant d'avoir à évaluer des conditions pour déterminer laquelle créer (ex. une switch). /// C'est aussi très flexible et réutilisable; la factory est aussi utilisée dans l'AI, par exemple. /// • J'ai créé des wrappers qui lient la factory à des affichages et qui gère l'affichage du nombre /// de pièces restantes selon la valeur que leur indiquent les générateur. /// • J'ai aussi créé un système d'animation qui place l'affichage des générateurs de pièces en cercle (trigonométrie) /// • Et j'ai implémenté un système de callback qui rappelle une fonction, donnée lors de la requête de pièce, /// au moment où on clique sur un générateur de pièces. Dans ce callback, on passe la pièce fraîchement créée. /// • Finalement, on peut aussi demander un pièce aléatoire, parmis ceux qui sont disponibles. Cette fonctionalité /// est utilisée lorsque l'on clique sur le bouton "aléatoire" : le programme détermine alors les cases où il n'y /// a pas de pièce et y met une pièce aléatoire. Ainsi, on peut placer les pièces importantes (ex. le drapeau /// entouré de bombes) et laisser le programme placer les autres aléatoirement dans les cases à combler. /// C'est pratique pour tester des stratégies sans avoir à placer toutes les pièces manuellement. /// </summary> public PrincipaleWindow() { InitializeComponent(); GestionnaireEcransJeu.Creer(new Dictionary <string, UserControl> { { "Accueil", new AccueilControl() }, { "Choix couleur", new ChoixCouleurControl() }, { "Placement des pieces", new PlacementPiecesControl() }, { "Partie", new JeuStrategoControl() } }, grdPrincipale.Children, "Accueil"); }
/// <summary> /// S'exécute lorsque l'on clique sur le bouton « Recommencer partie ». /// </summary> /// <param name="sender">Objet appelant</param> /// <param name="e">Arguments</param> private void btnRecommencerPartie_Click(object sender, RoutedEventArgs e) { bool bDecision = true; if (!EstDebutPartie && MessageBox.Show("Voulez-vous vraiment recommencer la partie ?", "Recommencer la partie", MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No) == MessageBoxResult.No) { bDecision = false; } if (bDecision) { GestionnaireEcransJeu.ChangerEcran("Choix couleur"); } }
/// <summary> /// Jouer un coup /// </summary> /// <param name="jeu"></param> private void JouerCoup(JeuStrategoControl jeu) { List <CoupCote> ListeCoupsPermis; Random rnd = new Random(DateTime.Now.Millisecond); int choixRnd; // On trouve les coups permis et on les ordonne ListeCoupsPermis = TrouverCoupsPermis(jeu.GrillePartie); ListeCoupsPermis.Sort(); // Si l'IA ne peut plus jouer, le joueur gagne. if (ListeCoupsPermis.Count == 0) { ((JeuStrategoControl)GestionnaireEcransJeu.GetEcranPresent()).TerminerPartie(); MessageBox.Show("Vous avez gagné (plus de mouvements possibles)!", "Victoire"); } // On choisi le bon coups et on le joue. List <CoupCote> ListeCoupsEgaux = new List <CoupCote>(); bool bEstPareille = true; int iScore = ListeCoupsPermis[0].Cote; for (int i = 0; i < ListeCoupsPermis.Count && bEstPareille; ++i) { if (ListeCoupsPermis[i].Cote != iScore) { bEstPareille = false; } else { ListeCoupsEgaux.Add(ListeCoupsPermis[i]); } } choixRnd = rnd.Next(0, ListeCoupsEgaux.Count); jeu.ExecuterCoup(ListeCoupsEgaux[choixRnd].Attaquant, ListeCoupsEgaux[choixRnd].Cible); }
/// <summary> /// S'exécute lorsque l'on clique sur le bouton « lancer partie ». /// </summary> /// <param name="sender">Objet appelant</param> /// <param name="e">Arguments</param> private void btnLancerPartie_Click(object sender, RoutedEventArgs e) => GestionnaireEcransJeu.ChangerEcran("Choix couleur");
/// <summary> /// Créer le gestionnaire /// </summary> /// <param name="ecransJeu">Liste des écrans</param> /// <param name="collectionAffichage">Affichage où afficher les écrans</param> /// <param name="premierEcran">Nom du premier écran à afficher</param> public static void Creer(Dictionary <string, UserControl> ecransJeu, UIElementCollection collectionAffichage, string premierEcran) => instance = new GestionnaireEcransJeu(ecransJeu, collectionAffichage, premierEcran);
/// <summary> /// Construction du contrôleur /// </summary> /// <param name="parametres">Paramètres en provenance du contrôleur précédent</param> public void Construire(Dictionary <string, ParametresConstruction> parametres) { CouleurJoueurs = (ParametresCouleurJoueurs)parametres["Couleur joueurs"]; grdPartie.IsEnabled = true; EstPartieTerminee = false; EstDebutPartie = true; GrillePartie = new GrilleJeu(CouleurJoueurs.CouleurJoueur, this); ConteneurPiecesCapturees = new ConteneurPiecesCapturees(stpPiecesCapturees); // Initialise la liste d'observateurs. observers = new List <IObserver <JeuStrategoControl> >(); // Initialiser l'IA. IA = new IA_Stratego(this, CouleurJoueurs.CouleurIA); DiviserGrilleJeu(); ColorerGrilleJeu(); DefinirZoneSelectionGrille(); InitialiserSelectionActive(); if (!PositionnerPieces(((ParametresPiecesJoueur)parametres["Pieces"]).Pieces)) { MessageBox.Show("Nombre de pièces ou couleurs invalide(s).", "Erreur", MessageBoxButton.OK, MessageBoxImage.Error); GestionnaireEcransJeu.ChangerEcran("Accueil"); } InitialiserAffichagePieces(); #region Tests // Code des tests initiaux. /* * ReponseDeplacement deplacement; * * deplacement = GrillePartie.ResoudreDeplacement(new Point(0, 6), new Point(0, 5)); // Deplacement * * deplacement = GrillePartie.ResoudreDeplacement(new Point(0, 5), new Point(-1, 5)); // Coord invalide * deplacement = GrillePartie.ResoudreDeplacement(new Point(2, 6), new Point(2, 5)); // Lac * * deplacement = GrillePartie.ResoudreDeplacement(new Point(2, 6), new Point(3, 6)); // Piece vs sa propre couleur * * deplacement = GrillePartie.ResoudreDeplacement(new Point(1, 6), new Point(1, 5)); * deplacement = GrillePartie.ResoudreDeplacement(new Point(1, 5), new Point(1, 4)); * deplacement = GrillePartie.ResoudreDeplacement(new Point(1, 4), new Point(1, 3)); // Prise par attaquant * * deplacement = GrillePartie.ResoudreDeplacement(new Point(1, 3), new Point(1, 2)); * deplacement = GrillePartie.ResoudreDeplacement(new Point(1, 2), new Point(1, 1)); * // deplacement = GrillePartie.ResoudreDeplacement(new Point(1, 1), new Point(1, 0)); // 2 pièces éliminées * deplacement = GrillePartie.ResoudreDeplacement(new Point(1, 1), new Point(2, 1)); * deplacement = GrillePartie.ResoudreDeplacement(new Point(2, 1), new Point(2, 0)); // Attaquant éliminé */ #endregion TourJeu = Couleur.Rouge; if (!GrillePartie.VerifierDeplacementsBombes(CouleurJoueurs.CouleurJoueur)) { TerminerPartie(); MessageBox.Show("Vous avez perdu (aucun mouvement possible)...", "Échec"); } if (!GrillePartie.VerifierDeplacementsBombes(CouleurJoueurs.CouleurIA)) { TerminerPartie(); MessageBox.Show("Vous avez gagné (aucun mouvement possible)!", "Victoire"); } // Lancer l'IA if (CouleurJoueurs.CouleurIA == Couleur.Rouge) { new Thread(LancerIA).Start(); } }
/// <summary> /// Exécuter un coup /// </summary> /// <param name="caseDepart">Case de départ</param> /// <param name="caseCible">Case de cible</param> /// <returns></returns> public ReponseDeplacement ExecuterCoup(Coordonnee caseDepart, Coordonnee caseCible) { if (EstPartieTerminee) { return(new ReponseDeplacement()); } Thread executionIA = new Thread(LancerIA); ReponseDeplacement reponse = new ReponseDeplacement(); Piece attaquant; Rectangle affichageAttaquant; Piece cible; Rectangle affichageCible; if (caseCible != caseDepart) { // Prendre les informations avant de faire le coup. attaquant = GrillePartie.ObtenirPiece(caseDepart); affichageAttaquant = GrillePieces[caseDepart.X][caseDepart.Y]; cible = GrillePartie.ObtenirPiece(caseCible); affichageCible = GrillePieces[caseCible.X][caseCible.Y]; if (GrillePartie.EstDeplacementPermis(caseDepart, caseCible) && cible != null && attaquant != null && !attaquant.EstVisible) { affichageAttaquant.Fill = new ImageBrush( new BitmapImage( new Uri( "sprites/" + (attaquant.EstDeCouleur(Couleur.Rouge) ? "Rouge/" : "Bleu/") + attaquant.Nom + ".png", UriKind.Relative ) ) ); attaquant.EstVisible = true; } if (GrillePartie.EstDeplacementPermis(caseDepart, caseCible) && cible != null && !cible.EstVisible) { affichageCible.Fill = new ImageBrush( new BitmapImage( new Uri( "sprites/" + (cible.EstDeCouleur(Couleur.Rouge) ? "Rouge/" : "Bleu/") + cible.Nom + ".png", UriKind.Relative ) ) ); cible.EstVisible = true; } reponse = GrillePartie.ResoudreDeplacement(caseDepart, caseCible); foreach (Piece piece in reponse.PiecesEliminees) { if (piece.EstDeCouleur(CouleurJoueurs.CouleurIA)) { ConteneurPiecesCapturees.AjouterPiece(piece); } } if (reponse.DeplacementFait) { // Retrait de la pièce attaquante de sa position d'origine. grdPartie.Children.Remove(affichageAttaquant); GrillePieces[caseDepart.X][caseDepart.Y] = null; if (reponse.PiecesEliminees.Count == 2) { // Retrait de la pièce attaquée. grdPartie.Children.Remove(GrillePieces[caseCible.X][caseCible.Y]); GrillePieces[caseCible.X][caseCible.Y] = null; } else if (reponse.PiecesEliminees.Count == 1 && reponse.PiecesEliminees[0] != attaquant || reponse.PiecesEliminees.Count == 0) { // Remplacement de la pièce attaquée par la pièce attaquante. grdPartie.Children.Remove(GrillePieces[caseCible.X][caseCible.Y]); GrillePieces[caseCible.X][caseCible.Y] = null; GrillePieces[caseCible.X][caseCible.Y] = affichageAttaquant; Grid.SetColumn(affichageAttaquant, caseCible.X); Grid.SetRow(affichageAttaquant, caseCible.Y); grdPartie.Children.Add(affichageAttaquant); } if (EstDebutPartie) { EstDebutPartie = false; } // Permet de faire jouer l'IA. if (TourJeu == CouleurJoueurs.CouleurJoueur) { executionIA.Start(); } ChangerTourJeu(); } } else { reponse.DeplacementFait = false; } // Si le joueur ne peut plus jouer, l'IA gagne. if (!JoueurACoupsPermis()) { ((JeuStrategoControl)GestionnaireEcransJeu.GetEcranPresent()).TerminerPartie(); MessageBox.Show("Vous avez perdu (plus de mouvements possibles)...", "Échec"); } return(reponse); }
private void btnRetour_Click(object sender, RoutedEventArgs e) => GestionnaireEcransJeu.ChangerEcran("Accueil");