/// <summary>
/// Tirer un missile aux coordonnées <paramref name="coord"/>
/// </summary>
/// <param name="grilleBateaux"></param>
/// <param name="grilleMissile"></param>
/// <param name="tabToucheBateaux"></param>
/// <param name="coord"></param>
/// <param name="tabTaillesBateaux"></param>
/// <returns>résultat du tir: type du bateau touché, 0 si aucun bateau touché, -1 erreur on a déjà tiré ici</returns>
public static int Tirer(int[,] grilleBateaux, int[,] grilleMissile
, int[] tabToucheBateaux, int[] coord, int[] tabTaillesBateaux)
{
if (Grille.EtreVide(grilleMissile, coord))
{
//il n'y a pas de bateaux à coord
if (Grille.EtreVide(grilleBateaux, coord))
{
grilleMissile[coord[0], coord[1]] = 1;
return(0);
}
else
{
grilleMissile[coord[0], coord[1]] = 2; //Bateau touché non coulé
//on décremente le nombre de case occupé par le bateau touché
tabToucheBateaux[grilleBateaux[coord[0], coord[1]] - 1] -= 1;
if (tabToucheBateaux[grilleBateaux[coord[0], coord[1]] - 1] == 0)
{
TransformerToucheEnCoule(grilleBateaux, grilleMissile, coord, tabTaillesBateaux);
}
return(grilleBateaux[coord[0], coord[1]]);
}
}
else
{
return(-1);
}
}
/// <summary>
/// Retourne en arrière depuis la coordonnée <paramref name="coord"/> dans la direction inverse à <paramref name="dir"/>
/// jusqu'à arriver à une case de type <paramref name="typePrec"/> située avant une case d'un type différent
/// </summary>
/// <param name="coord"></param>
/// <param name="dir"></param>
/// <param name="grilleMissileJoueur"></param>
/// <param name="grilleBateauxJoueur"></param>
/// <param name="typePrec"></param>
public static void RetournerArr(int[] coord, ref int dir, int[,] grilleMissileJoueur,
int[,] grilleBateauxJoueur, int typePrec)
{
int incx, incy;
dir = (dir + 2) % 4;
Grille.IncrementerversDir(dir, out incx, out incy);
int c = 1;
while (coord[0] + c * incx >= 0 &&
coord[0] + c * incx < grilleMissileJoueur.GetLength(0) &&
coord[1] + c * incy >= 0 &&
coord[1] + c * incy < grilleMissileJoueur.GetLength(1) &&
!(grilleMissileJoueur[coord[0] + c * incx,
coord[1] + c * incy] == 0) &&
grilleBateauxJoueur[coord[0] + c * incx,
coord[1] + c * incy] == typePrec
)
{
c++;
}
coord[0] = coord[0] + (c - 1) * incx;
coord[1] = coord[1] + (c - 1) * incy;
}
/// <summary>
/// Initialisation des coordonnées des tirs de l'ordinateur
/// </summary>
/// <param name="preCoord"></param>
/// <param name="grilleJoueurMissiles"></param>
/// <param name="rdn"></param>
public static void InitialiserPreCoord(int[][] preCoord, int[,] grilleJoueurMissiles, Random rdn)
{
int[] coord;
for (int i = 0; i < 5; i++)
{
do
{
coord = Grille.ChoisirCaseVideAlea(grilleJoueurMissiles, rdn);
} while (Grille.ContenirCoord(preCoord, coord));
preCoord[i] = coord;
}
}
/// <summary>
/// Regarde s'il y a un bateau dans la direction <paramref name="dir"/> à une distance inférieure ou égale à <paramref name="tailleBateau"/>
/// </summary>
/// <param name="grille"></param>
/// <param name="coord"></param>
/// <param name="dir"></param>
/// <param name="tailleBateau"></param>
/// <returns></returns>
public static bool AvoirBateauDansDirection(int[,] grille, int[] coord, int dir, int tailleBateau)
{
int incrementX, incrementY;
Grille.IncrementerversDir(dir, out incrementX, out incrementY);
bool result = false;
for (int i = 1; i <= tailleBateau; i++)
{
if (grille[coord[0] + i * incrementX, coord[1] + i * incrementY] != 0)
{
result = true;
break;
}
}
return(result);
}
/// <summary>
/// Tire sur la case de coordonnées <paramref name="coords"/>[<paramref name="index"/>]
/// et choisit aléatoirement les prochaines coordonnées
/// </summary>
/// <param name="grilleBateauxJoueur"></param>
/// <param name="grilleMissileJoueur"></param>
/// <param name="tabToucheBateauxJoueur"></param>
/// <param name="rdn"></param>
/// <param name="coords"></param>
/// <param name="dirs"></param>
/// <param name="goodDirs"></param>
/// <param name="typePrecs"></param>
/// <param name="tabtaillesBateaux"></param>
/// <param name="index"></param>
/// <param name="tirDispo"></param>
public static void ObtenirProchainCoup(int[,] grilleBateauxJoueur
, int[,] grilleMissileJoueur, int[] tabToucheBateauxJoueur
, Random rdn, int[][] coords, int[] dirs, bool[] goodDirs, int[] typePrecs, int[] tabtaillesBateaux, int index, int tirDispo)
{
int result = GrilleMissile.Tirer(grilleBateauxJoueur, grilleMissileJoueur
, tabToucheBateauxJoueur, coords[index], tabtaillesBateaux);
if (Grille.CompterNbCaseVide(grilleMissileJoueur) > tirDispo)
{
int[] coordInter;
do
{
//on en cherche une
coordInter = Grille.ChoisirCaseVideAlea(grilleMissileJoueur, rdn);
} while (Grille.ContenirCoord(coords, coordInter));
coords[index] = coordInter;
}
}
/// <summary>
/// Place un bateau aléatoirement sur <paramref name="grille"/> de type <paramref name="typeBateau"/>
/// </summary>
/// <param name="grille"></param>
/// <param name="tailleBateau"></param>
/// <param name="typeBateau"></param>
/// <param name="rdn"></param>
public static void CreerBateau(int[,] grille, int tailleBateau, int typeBateau, Random rdn)
{
int[] coord;
int direction;
do
{
coord = Grille.ChoisirCaseVideAlea(grille, rdn);
direction = ChoisirRandomDirectionBateau(tailleBateau, coord, grille, rdn);
} while (direction == -1);
int incrementX, incrementY;
Grille.IncrementerversDir(direction, out incrementX, out incrementY);
for (int i = 0; i < tailleBateau; i++)
{
grille[coord[0] + i * incrementX, coord[1] + i * incrementY] = typeBateau;
}
}
/// <summary>
/// Tire sur la case de coordonnées <paramref name="coords"/>[<paramref name="index"/>]
/// et choisit "intelligement" les prochaines coordonnées
/// </summary>
/// <param name="grilleBateauxJoueur"></param>
/// <param name="grilleMissileJoueur"></param>
/// <param name="tabToucheBateauxJoueur"></param>
/// <param name="rdn"></param>
/// <param name="coords"></param>
/// <param name="dirs"></param>
/// <param name="goodDirs"></param>
/// <param name="typePrecs"></param>
/// <param name="tabtaillesBateaux"></param>
/// <param name="index"></param>
/// <param name="tirDispo"></param>
public static void ObtenirProchainCoup(int[,] grilleBateauxJoueur
, int[,] grilleMissileJoueur, int[] tabToucheBateauxJoueur
, Random rdn, int[][] coords, int[] dirs, bool[] goodDirs, int[] typePrecs
, int[] tabtaillesBateaux, int index, int tirDispo)
{
int result = GrilleMissile.Tirer(grilleBateauxJoueur, grilleMissileJoueur
, tabToucheBateauxJoueur, coords[index], tabtaillesBateaux);
if (Grille.CompterNbCaseVide(grilleMissileJoueur) > tirDispo)
{
//choix de la prochaine coords[index]
int incx, incy;
int[] coordInter;
bool test;
//si on ne touche rien ou que l'on touche un autre navire que le navire recherché
if (result == 0 || (result != typePrecs[index] && typePrecs[index] != -1))
{
//si l'on n'a pas encore trouvé de cible
if (typePrecs[index] == -1)
{
do
{
//on en cherche une
coordInter = Grille.ChoisirCaseVideAlea(grilleMissileJoueur, rdn);
} while (Grille.ContenirCoord(coords, coordInter));
coords[index] = coordInter;
}
else if (tabToucheBateauxJoueur[typePrecs[index] - 1] != 0)
{
//on retourne dans la direction opposée
RetournerArr(coords[index], ref dirs[index], grilleMissileJoueur, grilleBateauxJoueur, typePrecs[index]);
//si on est pas sur le bon axe
if (!goodDirs[index])
{
//on choisis une direction aléatoire
dirs[index] = GrilleBateaux.ChoisirRandomDirectionBateau(1, coords[index],
grilleMissileJoueur, rdn);
}
Grille.IncrementerversDir(dirs[index], out incx, out incy);
// on avance d'une case dans la direction dirs[index]
coords[index] = new int[] { coords[index][0] + incx, coords[index][1] + incy };
}
else
{
dirs[index] = -1;
typePrecs[index] = -1;
goodDirs[index] = false;
do
{
//on en cherche une
coordInter = Grille.ChoisirCaseVideAlea(grilleMissileJoueur, rdn);
} while (Grille.ContenirCoord(coords, coordInter));
coords[index] = coordInter;
}
}
else
{
//debug
if (result == -1)
{
Console.WriteLine("erreur");
}
if (typePrecs[index] == -1)
{
typePrecs[index] = result;
}
//si la cible n'est pas coulée
if (tabToucheBateauxJoueur[typePrecs[index] - 1] != 0)
{
//si on suit une dirs[index]ection
if (dirs[index] != -1 && result == typePrecs[index])
{
goodDirs[index] = true;
}
do
{
//si on n est pas dans la bonne direction
if (!goodDirs[index])
{
dirs[index] = GrilleBateaux.ChoisirRandomDirectionBateau(1, coords[index],
grilleMissileJoueur, rdn);
}
Grille.IncrementerversDir(dirs[index], out incx, out incy);
coords[index] = new int[] { coords[index][0] + incx, coords[index][1] + incy };
if (coords[index][0] >= 0 && coords[index][0] < 10 &&
coords[index][1] >= 0 && coords[index][1] < 10)
{
//si la case a déjà été touchée et la case n'est pas déjà ciblée
test = grilleMissileJoueur[coords[index][0], coords[index][1]] != 0 && !coords.Contains(coords[index]);
if (test)
{
//on retourne dans la direction opposée
RetournerArr(coords[index], ref dirs[index], grilleMissileJoueur, grilleBateauxJoueur, typePrecs[index]);
}
}
else
{
test = true;
}
} while (test);
}
else
{
dirs[index] = -1;
typePrecs[index] = -1;
goodDirs[index] = false;
do
{
//on en cherche une
coordInter = Grille.ChoisirCaseVideAlea(grilleMissileJoueur, rdn);
} while (Grille.ContenirCoord(coords, coordInter));
coords[index] = coordInter;
}
}
}
}
/// <summary>
/// Lancement du jeu
/// </summary>
public static void Demarrer()
{
//constante
int[] tabTaillesBateaux = { 2, 3, 3, 4, 5 };
// définition grilles
int[,] grilleJoueurBateaux = new int[10, 10];
int[,] grilleOrdiBateaux = new int[10, 10];
int[,] grilleJoueurMissiles = new int[10, 10];
int[,] grilleOrdiMissiles = new int[10, 10];
//définition tableau
int[] tabToucheBateauxJoueur = tabTaillesBateaux.ToArray();
int[] tabToucheBateauxOrdi = tabTaillesBateaux.ToArray();
//random instance
Random rdn = new Random();
//variable difficulté
int diff = 0;
//paramètres de l'application
bool saveEachTurn = false;
string nameSave = "quicksave";
string path = Fichier.ObtenirPathSave();
//chargement des paramètres à partir du fichier parametre
path = Path.GetDirectoryName(path);
Fichier.LireSaveParametre(path + "\\" + "parametre.txt", ref saveEachTurn);
//init variable ordi
int[][] preCoord = new int[5][] { new int[2], new int[2], new int[2], new int[2], new int[2] };
int[] preDir = new int[] { -1, -1, -1, -1, -1 };
bool[] goodDir = new bool[] { false, false, false, false, false };
int[] typePrec = new int[] { -1, -1, -1, -1, -1 };
//placement bateau aléatoire sur la grille de l'ordinateur
InitialiserPreCoord(preCoord, grilleJoueurMissiles, rdn);
//boucle principale
int tour = 0;
bool joueur;
int tirsDispos;
int[] coord;
//menu principal
DemarrerMenuPrincipal(ref grilleJoueurBateaux, grilleJoueurMissiles, ref grilleOrdiBateaux,
grilleOrdiMissiles, tabTaillesBateaux, rdn, tabToucheBateauxJoueur, tabToucheBateauxOrdi
, ref diff, ref saveEachTurn, ref preDir, ref typePrec, preCoord, goodDir, ref tour);
do
{
//tour de qui?
joueur = (tour % 2 == 0);
//tour du joueur
if (joueur)
{
//sauvegarde auto
if (saveEachTurn)
{
Fichier.EcrireSavePartie(Fichier.ObtenirPathSave() + "\\" + nameSave,
new int[][, ] {
grilleJoueurBateaux, grilleOrdiBateaux,
grilleJoueurMissiles, grilleOrdiMissiles
},
new int[][] { tabToucheBateauxJoueur, tabToucheBateauxOrdi, preDir, typePrec }, preCoord, goodDir, diff, tour);
}
//affichage grilles
InterfaceJoueur.AfficherGrilles(grilleJoueurBateaux, grilleJoueurMissiles, grilleOrdiBateaux, grilleOrdiMissiles, 0, tabToucheBateauxJoueur, tabToucheBateauxOrdi, tour / 2);
//nombre de tirs disponible
tirsDispos = 5 - GrilleBateaux.CompterNombreBateauxCoule(tabToucheBateauxJoueur);
//init coord des tirs
int[,] coordTirs = new int[tirsDispos, 2];
for (int i = 0; i < coordTirs.GetLength(0); i++)
{
coordTirs[i, 0] = -1;
coordTirs[i, 1] = -1;
}
//demander les coordonnées des tirs
Action menu = () => DemarrerMenuContinue(grilleJoueurBateaux, grilleJoueurMissiles, grilleOrdiBateaux,
grilleOrdiMissiles, tabTaillesBateaux, rdn, tabToucheBateauxJoueur, tabToucheBateauxOrdi, diff,
preDir, typePrec, preCoord, goodDir, tour);
InterfaceJoueur.DemanderTirs(tirsDispos, 26, coordTirs
, menu);
//salve de tir
for (int i = 0; i < tirsDispos && tirsDispos < Grille.CompterNbCaseVide(grilleOrdiMissiles); i++)
{
coord = new int[2];
coord[0] = coordTirs[i, 0];
coord[1] = coordTirs[i, 1];
int result = GrilleMissile.Tirer(grilleOrdiBateaux, grilleOrdiMissiles, tabToucheBateauxOrdi, coord, tabTaillesBateaux);
}
}
//tour de l'ordi
else
{
//nombres de tirs dispo
tirsDispos = tabToucheBateauxOrdi.Length - GrilleBateaux.CompterNombreBateauxCoule(tabToucheBateauxOrdi);
//salve
for (int i = 0; i < tirsDispos && i < Grille.CompterNbCaseVide(grilleOrdiMissiles); i++)
{
//Facile
if (diff == 0)
{
Ordi_Facile.ObtenirProchainCoup(grilleJoueurBateaux, grilleJoueurMissiles,
tabToucheBateauxJoueur
, rdn, preCoord, preDir,
goodDir, typePrec, tabTaillesBateaux, i, tirsDispos);
}
//Difficile
else if (diff == 1)
{
Ordi_Difficile.ObtenirProchainCoup(grilleJoueurBateaux, grilleJoueurMissiles,
tabToucheBateauxJoueur
, rdn, preCoord, preDir,
goodDir, typePrec, tabTaillesBateaux, i, tirsDispos);
}
}
}
tour++;
} while (Grille.VerifierVictoire(tabToucheBateauxJoueur, tabToucheBateauxOrdi) == 0);
//Ecran de victoire
InterfaceJoueur.AfficherVictoire(Grille.VerifierVictoire(tabToucheBateauxJoueur, tabToucheBateauxOrdi), grilleJoueurBateaux, grilleJoueurMissiles, grilleOrdiBateaux, grilleOrdiMissiles, tabToucheBateauxJoueur, tabToucheBateauxOrdi, tour / 2);
}
