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