/// <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");