internal static int TrouverPos(int idPiece, int[,] plateau, int[][] piecesCalcul)
        {
            int x, y;
            int position = -1;

            for (int i = 0; i < 16; i++)
            {
                Utilisables.Pos2Coord(out x, out y, i);
                if (plateau[x, y] == -1)
                {
                    plateau[x, y] = idPiece;
                    if (Utilisables.TesterVictoire(idPiece, i, plateau, piecesCalcul))
                    {
                        position = i;
                        break;
                    }
                    plateau[x, y] = -1;
                }
            }
            if (position >= 0)
            {
                Utilisables.Pos2Coord(out x, out y, position);
                plateau[x, y] = -1;
            }
            return(position);
        }
        internal static bool PoserPiece(out int position, int idPiece, int[,] plateau)
        {
            int caseChoisie = rn.Next(0, 16);

            Utilisables.Pos2Coord(out int x, out int y, caseChoisie);
            while (plateau[x, y] >= 0)
            {
                caseChoisie = rn.Next(0, 16);
                Utilisables.Pos2Coord(out x, out y, caseChoisie);
            }
            plateau[x, y] = idPiece;
            IHM.AfficherCaseOrdi(x, y);
            position = caseChoisie;
            return(false);
        }
        internal static bool PoserPieceIA(out int position, int idPiece, int[,] plateau, int[][] piecesCalcul)
        {
            int x, y;

            position = TrouverPos(idPiece, plateau, piecesCalcul);
            if (position == -1)
            {
                PoserPiece(out position, idPiece, plateau);
            }
            else
            {
                Utilisables.Pos2Coord(out x, out y, position);
                plateau[x, y] = idPiece;
                IHM.AfficherCaseOrdi(x, y);
            }
            return(false);
        }
Beispiel #4
0
        internal static bool PoserPiece(out int position, int idPiece, int[,] plateau, bool sauvegarde, int[] piecesJouables)
        {
            bool choix = false;

            int colonneCourante = 0;
            int ligneCourante   = 0;
            int caseCourante    = 0;
            int indice          = 0;

            Utilisables.Pos2Coord(out int x, out int y, indice);


            while (plateau[x, y] != -1)
            {
                indice++;
                Utilisables.Pos2Coord(out x, out y, indice);
                if (plateau[x, y] == -1)
                {
                    caseCourante = indice;
                }
            }
            Utilisables.Pos2Coord(out ligneCourante, out colonneCourante, caseCourante);
            IHM.AfficherEcranJeux(plateau, caseCourante);
            while (!choix)
            {
                bool pause = false;
                System.ConsoleKeyInfo mouvement = Console.ReadKey();
                if (mouvement.Key == ConsoleKey.LeftArrow)
                {
                    colonneCourante = (colonneCourante -= 1) % 4;
                }
                else if (mouvement.Key == ConsoleKey.RightArrow)
                {
                    colonneCourante = (colonneCourante += 1) % 4;
                }
                else if (mouvement.Key == ConsoleKey.UpArrow)
                {
                    ligneCourante = (ligneCourante -= 1) % 4;
                }
                else if (mouvement.Key == ConsoleKey.DownArrow)
                {
                    ligneCourante = (ligneCourante += 1) % 4;
                }
                else if (mouvement.Key == ConsoleKey.Enter && plateau[ligneCourante, colonneCourante] == -1)
                {
                    plateau[ligneCourante, colonneCourante] = idPiece;
                    choix      = true;
                    sauvegarde = false;
                    IHM.EffacerChoixOrdi();
                }
                else if (mouvement.Key == ConsoleKey.P)
                {
                    sauvegarde = IHM.AfficherMenuPause(sauvegarde, plateau, piecesJouables);
                    pause      = true;
                }
                else if (mouvement.Key == ConsoleKey.Escape && sauvegarde == true)
                {
                    Environment.Exit(0);
                }
                else if (mouvement.Key == ConsoleKey.Escape && sauvegarde == false)
                {
                    IHM.AfficherQuitter(plateau, piecesJouables, caseCourante, -1, idPiece);
                }
                if (colonneCourante < 0)
                {
                    colonneCourante = Math.Abs(colonneCourante + 4) % 4;
                }
                if (ligneCourante < 0)
                {
                    ligneCourante = Math.Abs(ligneCourante + 4) % 4;
                }
                caseCourante = Coor2Pos(ligneCourante, colonneCourante);
                if (pause)
                {
                    IHM.AfficherEcranJeux(plateau, piecesJouables, caseCourante);
                    IHM.AfficherChoixOrdi(idPiece);
                }
                else
                {
                    IHM.AfficherEcranJeux(plateau, caseCourante);
                }
            }
            position = caseCourante;
            return(sauvegarde);
        }
Beispiel #5
0
        public static void Main(string[] args)
        {
            //Utilisables.JouerMusiqueIntro();
            int[,] plateau = new int[4, 4];     // variable représentant l'état du plateu de jeux pendant la partie
            int[] piecesJouables = new int[16]; // variable contenant l'identifiant des pieces encore disponibles
            //int[] piecesJouees = new int[16]; // variable contenant l'identifiant des pieces déjà placées sur le plateau

            IHM.InitialiserGraphiques();
            IHM.AfficherIntro();
            //============================================================================================================
            //                                  Affichage du menu principal du jeu
            //============================================================================================================
            int  boutonCourantMenu = 1; // Initialisation du bouton courant du menu
            bool menu = true;

            // Boucle permettant d'afficher le menu de manière interactive
            while (menu)
            {
                IHM.AfficherMenu(boutonCourantMenu);
                System.ConsoleKeyInfo Bouton = Console.ReadKey();
                switch (Bouton.Key)
                {
                case ConsoleKey.LeftArrow:
                case ConsoleKey.UpArrow:
                    boutonCourantMenu = (boutonCourantMenu -= 1) % 3;
                    break;

                case ConsoleKey.RightArrow:
                case ConsoleKey.DownArrow:
                    boutonCourantMenu = (boutonCourantMenu += 1) % 3;
                    break;

                case ConsoleKey.Enter:
                    if (boutonCourantMenu == 2)
                    {
                        Environment.Exit(0);                             // Bouton Quitter
                    }
                    else if (boutonCourantMenu == 1)
                    {
                        menu = false;                                    // Bouton Jouer
                    }
                    else
                    {
                        Console.Clear(); IHM.AfficherRegles();
                    }                                                    // Bouton Règles
                    break;
                }

                /*// Définition des touches permettants de parcourir les boutons du menu
                 * if (Bouton.Key == ConsoleKey.LeftArrow) boutonCourantMenu = (boutonCourantMenu -= 1) % 3;
                 * else if (Bouton.Key == ConsoleKey.RightArrow) boutonCourantMenu = (boutonCourantMenu += 1) % 3;
                 *
                 * // Action à réaliser quand un bouton est selectionné
                 * else if (Bouton.Key == ConsoleKey.Enter)
                 * {
                 *  if (boutonCourantMenu == 2) Environment.Exit(0); // Bouton Quitter
                 *  else if (boutonCourantMenu == 1) menu = false;   // Bouton Jouer
                 *  else { Console.Clear(); IHM.AfficherRegles(); }  // Bouton Règles
                 * }*/
                if (boutonCourantMenu < 0)
                {
                    boutonCourantMenu = Math.Abs(boutonCourantMenu + 3);                        // Permet de réaliser le "modulo négatif"
                }
            }
            bool jouer = true;

            while (jouer)
            {
                //============================================================================================================
                //                                  Affichage du menu de chargement de partie
                //============================================================================================================
                int  BoutonChargerCourant = 1;
                bool nouveauJeux          = true;
                bool charger = false;
                while (nouveauJeux)                                                        // Menu de jeu, charger, nouvelle partie
                {
                    IHM.AfficherEcranChargement(BoutonChargerCourant);
                    System.ConsoleKeyInfo Bouton = Console.ReadKey();
                    switch (Bouton.Key)
                    {
                    case ConsoleKey.LeftArrow:
                    case ConsoleKey.UpArrow:
                        BoutonChargerCourant = (BoutonChargerCourant -= 1) % 2;
                        break;

                    case ConsoleKey.RightArrow:
                    case ConsoleKey.DownArrow:
                        BoutonChargerCourant = (BoutonChargerCourant += 1) % 2;
                        break;

                    case ConsoleKey.Enter:
                        if (BoutonChargerCourant == 0)
                        {
                            nouveauJeux = false;
                        }
                        else
                        {
                            charger     = true;
                            nouveauJeux = false;
                        }
                        break;
                    }

                    /*
                     * if (Bouton.Key == ConsoleKey.LeftArrow) BoutonChargerCourant = (BoutonChargerCourant -= 1) % 2;
                     * else if (Bouton.Key == ConsoleKey.RightArrow) BoutonChargerCourant = (BoutonChargerCourant += 1) % 2;
                     * else if (Bouton.Key == ConsoleKey.Enter)
                     * {
                     *  if (BoutonChargerCourant == 0) nouveauJeux = false;
                     *  else
                     *  {
                     *      charger = true;
                     *      nouveauJeux = false;
                     *  }
                     * }
                     */
                    //BoutonChargerCourant = BoutonChargerCourant < 0 ? Math.Abs(BoutonChargerCourant + 2) % 2 : BoutonChargerCourant;
                    if (BoutonChargerCourant < 0)
                    {
                        BoutonChargerCourant = Math.Abs(BoutonChargerCourant + 2);
                    }
                }
                //============================================================================================================
                string nomFichier = "../../Sauvegardes\\Z_NouvellePartie.txt";
                //============================================================================================================
                //                                  Création de la partie chargée ou non
                //============================================================================================================
                if (charger == true) // Si on charge un sauvegarde
                {
                    nomFichier = IHM.AfficherPageChargement();
                }
                // Initialisation du tableau et des pieces pour la partie
                Utilisables.InitialiserPartie(nomFichier, ref plateau, ref piecesJouables);
                IHM.InitialiserEcranJeux();

                int caseCourante  = -1;
                int pieceCourante = -1;
                IHM.AfficherEcranJeux(plateau, piecesJouables, caseCourante, pieceCourante);
                int  tour   = 0;
                bool gagner = false;
                //============================================================================================================
                //                           Départ de la Boucle de jeux pour un Player vs Ordi
                //============================================================================================================
                bool  sauvegarde  = false;
                bool  joueur      = true;
                int[] piecesVides = new int[] { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
                while (!gagner)
                {
                    if (piecesJouables.SequenceEqual(piecesVides))
                    {
                        IHM.AfficherEgalite();
                    }
                    // Tour de l'ordinateur
                    if (tour % 2 == 0)
                    {
                        int idPiece = Utilisables.ChoisirPiece(piecesJouables, sauvegarde, plateau);
                        IHM.AfficherEcranJeux(piecesJouables);
                        sauvegarde = IA.PoserPiece(out int position, idPiece, plateau);
                        IHM.AfficherEcranJeux(plateau);
                        gagner = Utilisables.TesterVictoire(idPiece, position, plateau);
                    }
                    // Tour du joueur
                    else
                    {
                        int idPiece = IA.ChoisirPiece(piecesJouables);
                        sauvegarde = false;
                        IHM.AfficherEcranJeux(piecesJouables);
                        sauvegarde = Utilisables.PoserPiece(out int position, idPiece, plateau, sauvegarde, piecesJouables);
                        IHM.AfficherEcranJeux(plateau);
                        gagner = Utilisables.TesterVictoire(idPiece, position, plateau);
                        if (gagner)
                        {
                            joueur = false;
                        }
                    }
                    tour++;
                }
                //IHM.AnimationVictoire();
                IHM.AfficherEcranVictoire(joueur);
                jouer = IHM.AfficherRejouer();
            }

            //Console.Read();
        }