예제 #1
0
 /// <summary>
 /// Sauvegarde les données de la partie en cours dans un fichier texte de sauvegarde
 /// </summary>
 public static void Sauvegarder()
 {
     if (File.Exists(Sauvegarde.NomFichier()) && Sauvegarde.DemandeEffacerAnciennePartie() == false)
     {
         NomFichierIndex = Sauvegarde.RecupererDernierIndexSauvegarde() + 1;
     }
     // Sauvegarde positions J1
     string[] lignes = Sauvegarde.ConvertirObjetEnLigne(new string[0], Bateau.ObtenirPositionBateauxJoueur(1));
     // Sauvegarde vies J1
     lignes = Sauvegarde.ConvertirObjetEnLigne(lignes, Bateau.ObtenirVieBateauxJoueur(1));
     // Sauvegarde positions J2
     lignes = Sauvegarde.ConvertirObjetEnLigne(lignes, Bateau.ObtenirPositionBateauxJoueur(2));
     // Sauvegarde vies J2
     lignes = Sauvegarde.ConvertirObjetEnLigne(lignes, Bateau.ObtenirVieBateauxJoueur(2));
     // Sauvegarde grille j1
     lignes = Sauvegarde.ConvertirObjetEnLigne(lignes, Grille.ObtenirGrilleJoueur(1));
     // Sauvegarde grille decouverte J1
     lignes = Sauvegarde.ConvertirObjetEnLigne(lignes, Grille.ObtenirGrilleDecouverteJoueur(1));
     // Sauvegarde grille J2
     lignes = Sauvegarde.ConvertirObjetEnLigne(lignes, Grille.ObtenirGrilleJoueur(2));
     // Sauvegarde grille decouverte J2
     lignes = Sauvegarde.ConvertirObjetEnLigne(lignes, Grille.ObtenirGrilleDecouverteJoueur(2));
     // Sauvegarde niveau
     lignes = lignes.Concat(new string[] { ((int)Jeu.NiveauJeu).ToString() }).ToArray();
     File.WriteAllLines(Sauvegarde.NomFichier(), lignes);
     Console.Clear();
     Console.WriteLine("======= Sauvegarder une partie ===");
     Console.ForegroundColor = ConsoleColor.Green;
     Console.WriteLine("Votre partie a été sauvegardée dans le fichier " + Sauvegarde.NomFichier());
     Console.ResetColor();
     Console.WriteLine("-- Appuyez sur une touche pour continuer --");
     Console.ReadKey(false);
 }
예제 #2
0
        /// <summary>
        /// Modifie la vie du bateau passé en paramètre associé au joueur passé en paramètres
        /// </summary>
        /// <param name="joueur">Joueur dont on doit modifier un bateau</param>
        /// <param name="type">Type de bateau dont on doit modifier la vie </param>
        /// <param name="x">Position x à la quelle le bateau a été touché</param>
        /// <param name="y">Position y à laquelle le bateau a été touché</param>
        /// <returns>Vrai si le bateau est coulé, Faux sinon</returns>
        public static bool ToucherBateau(int joueur, Bateau.TYPES type, int x, int y)
        {
            int[,] positionbateau = Bateau.ObtenirPositionBateauxJoueur(joueur);
            int[] vieBateaux = Bateau.ObtenirVieBateauxJoueur(joueur);
            int[,] grille         = Grille.ObtenirGrilleJoueur(joueur);
            grille[x, y]          = (int)Grille.Cases.TOUCHE;
            int[,] decouverte     = Grille.ObtenirGrilleDecouverteJoueur(Joueur.ObtenirAutreJoueur(joueur));
            decouverte[x, y]      = (int)Grille.Cases.TOUCHE;
            vieBateaux[(int)type] = vieBateaux[(int)type] - 1;
            //vieBateaux[(int)type] = 0;

            if (vieBateaux[(int)type] <= 0)
            {
                // On marque la bateau comme coulé sur la grille
                for (int o = 0; o < Bateau.LongueurBateaux[(int)type]; o++)
                {
                    if (Bateau.ObtenirAlignementBateau(joueur, type) == ALIGNEMENT.COLONNE)
                    {
                        grille[positionbateau[(int)type, 0], positionbateau[(int)type, 1] + o]     = (int)Grille.Cases.COULE;
                        decouverte[positionbateau[(int)type, 0], positionbateau[(int)type, 1] + o] = (int)Grille.Cases.COULE;
                    }
                    else
                    {
                        grille[positionbateau[(int)type, 0] + o, positionbateau[(int)type, 1]]     = (int)Grille.Cases.COULE;
                        decouverte[positionbateau[(int)type, 0] + o, positionbateau[(int)type, 1]] = (int)Grille.Cases.COULE;
                    }
                }
                return(true);
            }
            return(false);
        }
예제 #3
0
        /// <summary>
        /// Paramètre les positions du bateau passé en paramètre dans la liste des positions de bateau
        /// </summary>
        /// <param name="joueur">Joueur associé au bateau à placer</param>
        /// <param name="type">Type de bateau à placer</param>
        /// <param name="x">Position x du premier point de la droite associée au bateau à placer</param>
        /// <param name="y">Position y du premier point de la droite associée au bateau à placer</param>
        /// <param name="alignement">Alignement du bateau à placer</param>
        public static void PlacerBateau(int joueur, Bateau.TYPES type, int x, int y, Bateau.ALIGNEMENT alignement)
        {
            int[,] positionBateaux = Bateau.ObtenirPositionBateauxJoueur(joueur);
            int[] vieBateaux = Bateau.ObtenirVieBateauxJoueur(joueur);
            int   x1;
            int   y1;


            if (alignement == ALIGNEMENT.LIGNE)
            {
                x1 = x + Bateau.LongueurBateaux[(int)type] - 1;
                y1 = y;
            }
            else
            {
                y1 = y + Bateau.LongueurBateaux[(int)type] - 1;
                x1 = x;
            }

            if (x < 0 || y < 0 || x1 >= Grille.LargeurGrille || y1 >= Grille.LargeurGrille)
            {
                throw new Exception("Impossible de placer le bateau. Il se trouve en dehors de la grille.");
            }

            vieBateaux[(int)type]         = Bateau.LongueurBateaux[(int)type];
            positionBateaux[(int)type, 0] = x;
            positionBateaux[(int)type, 1] = y;
            positionBateaux[(int)type, 2] = x1;
            positionBateaux[(int)type, 3] = y1;

            Grille.mettreaJourGrilleUnBateau(Grille.ObtenirGrilleJoueur(joueur), x, y, x1, y1);
        }
예제 #4
0
 /// <summary>
 /// Affiche la grille passée en paramètre dans la console
 /// </summary>
 /// <param name="grille">Grille à afficher</param>
 public static void AfficherGrille(int[,] grille)
 {
     string[] lignes = Grille.ConvertirGrilleVersTexte(grille).Split("\n".ToCharArray());
     for (int i = 0; i < lignes.Length; i++)
     {
         Grille.AfficherLigneCouleur(lignes[i]);
         Console.WriteLine("");
     }
 }
예제 #5
0
 /// <summary>
 /// Calcule "très naivement" la position d'un tir de l'IA vers une cellule donnée
 /// </summary>
 /// <param name="joueur">joueur correspondant à l'IA</param>
 /// <param name="x">Entrée-sortie, à la fin de la fonction, contient la position x du tir</param>
 /// <param name="y">Entrée-sortie, à la fin de la fonction, contient la position y du tir</param>
 private static void PositionIAEnfant(int joueur, out int x, out int y)
 {
     do
     {
         Random rdm = Program.random;
         x = rdm.Next(0, Grille.LargeurGrille);
         y = rdm.Next(0, Grille.HauteurGrille);
     }while (Grille.ObtenirGrilleDecouverteJoueur(joueur)[x, y] != (int)Grille.Cases.VIDE);
 }
예제 #6
0
 /// <summary>
 /// Met à jour la grille à partir de la position de plusieurs bateaux
 /// </summary>
 /// <param name="grille">Grille à mettre à jour</param>
 /// <param name="positionbateaux">Tableau en 2 dimensions contenant les positions de plusieurs bateaux</param>
 public static void mettreaJourGrillePlusieursBateaux(int[,] grille, int [,] positionbateaux)
 {
     for (int j = 0; j < (Bateau.NombreTypesBateaux); j++)
     {
         int x1 = positionbateaux[j, 0];
         int y1 = positionbateaux[j, 1];
         int x2 = positionbateaux[j, 2];
         int y2 = positionbateaux[j, 3];
         Grille.mettreaJourGrilleUnBateau(grille, x1, y1, x2, y2);
     }
 }
예제 #7
0
        /// <summary>
        /// Affiche et gère l'écran de paramétrage d'une nouvelle partie
        /// </summary>
        public static void MenuDemarrerNouvellePartie()
        {
            Console.Clear();
            Joueur.Start();
            // On met à jour l'index de sauvegarde pour éviter d'écraser une ancienne partie
            Sauvegarde.NomFichierIndex = Sauvegarde.RecupererDernierIndexSauvegarde() + 1;


            // Initialisation des grilles
            Grille.GrilleJ1           = new int[Grille.LargeurGrille, Grille.HauteurGrille];
            Grille.GrilleDecouverteJ1 = new int[Grille.LargeurGrille, Grille.HauteurGrille];

            Grille.GrilleJ2           = new int[Grille.LargeurGrille, Grille.HauteurGrille];
            Grille.GrilleDecouverteJ2 = new int[Grille.LargeurGrille, Grille.HauteurGrille];

            // Initialisation des données des bateaux des joueurs
            Bateau.PositionBateauxJ1 = new int[Bateau.NombreTypesBateaux, 4];
            Bateau.VieBateauxJ1      = new int[Bateau.NombreTypesBateaux];

            Bateau.PositionBateauxJ2 = new int[Bateau.NombreTypesBateaux, 4];
            Bateau.VieBateauxJ2      = new int[Bateau.NombreTypesBateaux];

            Bateau.PlacerBateauxAuHasard(1);
            Bateau.PlacerBateauxAuHasard(2);

            //TODO: modifier ce code si on souhaite ajouter un mode JCJ
            Console.WriteLine("======= Nouvelle partie =======");
            Grille.AfficherGrille(Grille.GrilleJ1);
            Console.WriteLine("-------------------------------");
            ConsoleKey key = default(ConsoleKey);

            do
            {
                if (key != default(ConsoleKey))
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                }
                Console.WriteLine("Etes-vous satisfait de ce placement ?");
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("(O)ui | N(on)");
                Console.ResetColor();
                key = Console.ReadKey(false).Key;
            }while (key != ConsoleKey.O && key != ConsoleKey.N);
            Program.ViderTampon();
            if (key == ConsoleKey.O)
            {
                Jeu.DeroulementPartie();
            }
            else
            {
                Jeu.MenuDemarrerNouvellePartie();
            }
        }
예제 #8
0
        /// <summary>
        /// Permet d'afficher deux représentations de grilles côtes à cotes
        /// </summary>
        /// <param name="grille1">Grille à afficher à gauche</param>
        /// <param name="grille2">Grille à afficher à droite</param>
        public static void AfficherDeuxGrillesCoteACote(int[,] grille1, int[,] grille2)
        {
            string[] g1 = Grille.ConvertirGrilleVersTexte(grille1).Split("\n".ToCharArray());
            string[] g2 = Grille.ConvertirGrilleVersTexte(grille2).Split("\n".ToCharArray());

            for (int i = 0; i < g1.Length && i < g2.Length; i++)
            {
                string ligne = g1[i] + "    " + g2[i];
                Grille.AfficherLigneCouleur(ligne);
                if (i < g1.Length - 1 && i < g2.Length)
                {
                    Console.Write("\n");
                }
            }
        }
예제 #9
0
        /// <summary>
        /// Permet de jouer un tour en tant qu'IA
        /// </summary>
        /// <param name="joueur">Joueur concerné</param>
        public static void JouerIA(int joueur)
        {
            int x, y;

            int[,] salves = new int[Joueur.ObtenirTailleSalve(joueur), 2];
            for (int i = 0; i < salves.GetLength(0); i++)
            {
                IA.PositionIA(joueur, out x, out y, i);
                salves[i, 0] = x;
                salves[i, 1] = y;
            }

            for (int i = 0; i < salves.GetLength(0); i++)
            {
                x = salves[i, 0];
                y = salves[i, 1];
                Console.Write("L'ordinateur tire sur la cellule " + Grille.Lettres[y] + "" + (x + 1) + " ...");
                int[,] decouverte;
                bool coule = false;
                if (Bateau.Tirer(joueur, x, y, out coule) == true) // IA a touché
                {
                    IA.SignalerTouche(i);
                    Console.ForegroundColor = ConsoleColor.Red;
                    if (coule)
                    {
                        Console.WriteLine("L'ordinateur a coulé un navire !");
                        IA.SignalerCoule(joueur, i);
                        Joueur.ReglerTailleSalve(joueur, Joueur.ObtenirTailleSalve(joueur) - 1);
                    }
                    else
                    {
                        Console.WriteLine("L'ordinateur a touché un navire !");
                    }
                    Console.ResetColor();
                }
                else // IA n'a pas touché
                {
                    IA.SignalerRate(i);
                    Console.WriteLine("C'est un coup dans l'eau...");
                    decouverte       = Grille.ObtenirGrilleDecouverteJoueur(joueur);
                    decouverte[x, y] = (int)Grille.Cases.DECOUVERT_VIDE;
                }
            }
        }
예제 #10
0
        /// <summary>
        /// Tente un tir sur une cellule par le joueur précisé
        /// </summary>
        /// <param name="joueur">Joueur réalisant le tir</param>
        /// <param name="x">Position x de la cellule visée</param>
        /// <param name="y">Position y de la cellule visée</param>
        /// <param name="coule">Paramètre entrée sortie, contient vrai si un bateau a été coulé suite au tir</param>
        /// <returns>Vrai si un bateau a été touché, faux sinon</returns>
        public static bool Tirer(int joueur, int x, int y, out bool coule)
        {
            coule = false;
            if (Grille.ObtenirGrilleDecouverteJoueur(joueur)[x, y] != (int)Grille.Cases.VIDE)
            {
                return(false);
            }
            int[,] positionBateaux = null;
            int[] vieBateaux = null;
            if (joueur == 1)
            {
                positionBateaux = Bateau.PositionBateauxJ2;
                vieBateaux      = Bateau.VieBateauxJ2;
            }
            else if (joueur == 2)
            {
                positionBateaux = Bateau.PositionBateauxJ1;
                vieBateaux      = Bateau.VieBateauxJ1;
            }
            bool trouve = false;
            int  i      = 0;

            while (trouve == false && i < Bateau.NombreTypesBateaux)
            {
                trouve = positionBateaux[i, 0] <= x && x <= positionBateaux[i, 2] && positionBateaux[i, 1] <= y && y <= positionBateaux[i, 3];
                i++;
            }

            if (trouve == true)
            {
                coule = Bateau.ToucherBateau(Joueur.ObtenirAutreJoueur(joueur), (Bateau.TYPES)(i - 1), x, y);
            }
            else
            {
                int[,] decouverte = Grille.ObtenirGrilleDecouverteJoueur(joueur);
                decouverte[x, y]  = (int)Grille.Cases.DECOUVERT_VIDE;
            }
            return(trouve);
        }
예제 #11
0
        /// <summary>
        /// Renvoie une position au hasard de manière "non-naive" (c'est à dire en prenant en compte les tirs des autres canons, et les tirs déja effectués)
        /// </summary>
        /// <param name="joueur">Joueur associé à l'IA</param>
        /// <param name="x">Entrée-sortie, à la fin de la fonction, contient la position x du tir</param>
        /// <param name="y">Entrée-sortie, à la fin de la fonction, contient la position y du tir</param>
        /// <param name="canon">Index du canon utilisé</param>
        private static void PositionAuHasard(int joueur, out int x, out int y, int canon)
        {
            bool positionValide = true;

            do
            {
                Random rdm = Program.random;
                x = rdm.Next(0, Grille.LargeurGrille);
                y = rdm.Next(0, Grille.HauteurGrille);
                // On vérifie si on a déjà tiré dans cette case
                positionValide = Grille.ObtenirGrilleDecouverteJoueur(joueur)[x, y] == (int)Grille.Cases.VIDE;
                int i = 0;
                // On vérifie que ce tour si, un autre canon n'est pas déjà réglé dans cette direction
                while (i < canon && positionValide == true)
                {
                    if (x == IA.DerniersTirsX[i] && y == IA.DerniersTirsY[i])
                    {
                        positionValide = false;
                    }
                    i++;
                }
            }while (positionValide == false);
        }
예제 #12
0
 /// <summary>
 /// Détermine si les positions passées en paramètres sont libres ou occupées par un bateau
 /// </summary>
 /// <param name="joueur">Joueur dont on doit tester les bateaux</param>
 /// <param name="x1">Position x du premier point de la droite à tester</param>
 /// <param name="y1">Position y du premier point de la droite à tester</param>
 /// <param name="x2">Position x du deuxième point de la droite à tester</param>
 /// <param name="y2">Position y du deuxième point de la droite à tester</param>
 /// <param name="type">Type de bateau associé aux points à tester</param>
 /// <returns>Vrai si position libre, Faux si position occupée</returns>
 public static bool VerifierColisionBateaux(int joueur, int x1, int y1, int x2, int y2, Bateau.TYPES type)
 {
     int[,] grille = Grille.ObtenirGrilleJoueur(joueur);
     for (int o = 0; o < Bateau.LongueurBateaux[(int)type]; o++)
     {
         // Si le bateau est aligné en colonne
         if (x1 == x2)
         {
             if (grille[x1, y1 + o] != (int)Grille.Cases.VIDE)
             {
                 return(false);
             }
         }
         else //sinon le bateau est aligné en ligne
         {
             if (grille[x1 + o, y1] != (int)Grille.Cases.VIDE)
             {
                 return(false);
             }
         }
     }
     return(true);
 }
예제 #13
0
        /// <summary>
        /// Permet de joueur un tour en tant qu'humain
        /// </summary>
        /// <param name="joueur">Joueur concerné</param>
        public static void JouerHumain(int joueur)
        {
            int x, y;

            int[,] salves = new int[Joueur.ObtenirTailleSalve(joueur), 2];

            /*Console.WriteLine("Votre Grille:");
             * Grille.AfficherGrille(Grille.ObtenirGrilleJoueur(joueur));
             * Console.WriteLine("Ce que vous savez de la Grille de l'adversaire:");
             * Grille.AfficherGrille(Grille.ObtenirGrilleDecouverteJoueur(joueur));*/
            for (int i = 0; i < salves.GetLength(0); i++)
            {
                Console.Clear();
                Console.ForegroundColor = ConsoleColor.Blue;
                Console.WriteLine("==TOUR DU JOUEUR " + joueur + "=============");
                Console.ResetColor();
                string infoGrilles = "Votre Grille:                          Ce que vous savez de la grille de votre adversaire:";
                Console.WriteLine(infoGrilles);
                Grille.AfficherDeuxGrillesCoteACote(Grille.ObtenirGrilleJoueur(joueur), Grille.ObtenirGrilleDecouverteJoueur(joueur));
                Console.WriteLine("\n-------\nParamétrage du canon " + (i + 1) + "/" + salves.GetLength(0));
                Console.Write("Tirs paramétrés: ");
                Console.ForegroundColor = ConsoleColor.DarkYellow;
                for (int o = 0; o < i; o++)
                {
                    Console.Write(Grille.Lettres[salves[o, 1]] + "" + (salves[o, 0] + 1) + " ");
                }
                Console.WriteLine("");
                Console.ResetColor();
                DemanderPosition(joueur, out x, out y);
                salves[i, 0] = x;
                salves[i, 1] = y;
                Console.WriteLine("Un canon a été dirigé vers la cellule " + Grille.Lettres[y] + "" + (x + 1) + " ...");
            }
            Console.Clear();
            Console.WriteLine("------------------------");
            Console.WriteLine("Mise à feu des canons...");
            for (int i = 0; i < salves.GetLength(0); i++)
            {
                x = salves[i, 0];
                y = salves[i, 1];
                Console.Write("Tir sur la cellule " + Grille.Lettres[y] + "" + (x + 1) + " ...");
                bool coule = false;
                if (Bateau.Tirer(joueur, x, y, out coule) == true) // le joueur a touché
                {
                    if (coule == false)
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine("Vous avez touché un navire !");
                        Console.ResetColor();
                    }
                    else
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine("Un bateau a été coulé.");
                        Console.ResetColor();
                        Joueur.ReglerTailleSalve(joueur, Joueur.ObtenirTailleSalve(joueur) - 1);
                    }
                }
                else // le joueur n'a pas touché
                {
                    Console.WriteLine("C'est un coup dans l'eau...");
                }
            }
        }
예제 #14
0
        /// <summary>
        /// Calcule "intelligement" la position d'un tir de l'IA vers une cellule donnée
        /// </summary>
        /// <param name="joueur">joueur correspondant à l'IA</param>
        /// <param name="x">Entrée-sortie, à la fin de la fonction, contient la position x du tir</param>
        /// <param name="y">Entrée-sortie, à la fin de la fonction, contient la position y du tir</param>
        /// <param name="canon">Index du canon utilisé</param>
        private static void PositionIANormal(int joueur, out int x, out int y, int canon)
        {
            if (IA.initialized == false)
            {
                IA.Start();
            }

            if (IA.DirectionsTirs[canon] == -1)
            {
                IA.PositionAuHasard(joueur, out x, out y, canon);
                IA.DerniersTirsX[canon] = x;
                IA.DerniersTirsY[canon] = y;
                return;
            }

            switch (IA.DirectionsTirs[canon])
            {
            default:
            case 0:
                x = IA.DerniersTirsX[canon] - 1;
                y = IA.DerniersTirsY[canon];
                break;

            case 1:
                x = IA.DerniersTirsX[canon];
                y = IA.DerniersTirsY[canon] - 1;
                break;

            case 2:
                x = IA.DerniersTirsX[canon] + 1;
                y = IA.DerniersTirsY[canon];
                break;

            case 3:
                x = IA.DerniersTirsX[canon];
                y = IA.DerniersTirsY[canon] + 1;
                break;
            }

            IA.DerniersTirsX[canon] = x;
            IA.DerniersTirsY[canon] = y;

            IA.DerniersTirsCombo[canon]++;

            if (x < 0 || x >= Grille.LargeurGrille || y < 0 || y >= Grille.HauteurGrille || Grille.ObtenirGrilleDecouverteJoueur(joueur)[x, y] != (int)Grille.Cases.VIDE)
            {
                IA.SignalerRate(canon);
                IA.PositionIANormal(joueur, out x, out y, canon);
            }
        }