/// <summary>
/// Routine de décryptage de la carte
/// </summary>
public static void DecrypterUneTrame()
{
(string, string, string)CheminNomEtDestination;
string reponse = "*";
CheminNomEtDestination = Affichage.DemanderCheminTrame();
try
{
Decrypteur.DecrypterLaTrame(CheminNomEtDestination.Item1,
CheminNomEtDestination.Item2, CheminNomEtDestination.Item3);
Carte carte = new Carte(CheminNomEtDestination.Item3 +
CheminNomEtDestination.Item2 + ".clair",
CheminNomEtDestination.Item2);
Affichage.DecryptageEnCours();
while (reponse != "")
{
Affichage.AfficherCarteDecryptee(carte,
CheminNomEtDestination.Item3);
reponse = Console.ReadLine();
Console.Clear();
}
Menu.MenuPrinciapl();
}
catch (Exception)
{
Affichage.ErreurChemin();
Thread.Sleep(2000);
Console.Clear();
Menu.DecrypterUneTrame();
}
}
/// <summary>
/// Algorithme de décryptage, il agit unité par unité et applique la
/// lettre à l'unité mais aussi à tous ses voisins. Il détecte une
/// le commencement d'une nouvelle parcelle en vérifiant si les
/// voisins sont nulls eux aussi. Il procède par balayage de haut en
/// bas et de droite à gauche.
/// </summary>
/// <param name="carte">Tableau de la carte en référence</param>
/// <param name="frontieres">Tableau des frontières</param>
/// <param name="x">Coordonnée x de l'unité</param>
/// <param name="y">Coordonnée y de l'unité</param>
/// <param name="ASCII">Code ASCII en ref(prochaine lettre)</param>
private static void AlgorithmeDecryptage(ref char[,] carte,
int[,] frontieres, int x, int y, ref int ASCII)
{
(bool, bool, bool, bool)NordOuestSudEst =
Decrypteur.LectureBinaireVoisins(frontieres[y, x]);
char lettre = '*';
// Vérification des lettres des voisins
// lettre change de valeur si une unité voisine n'est pas nulle
if (NordOuestSudEst.Item1)
{
Decrypteur.ParcourirNord(ref lettre, carte, frontieres, x, y);
}
if (NordOuestSudEst.Item2)
{
Decrypteur.ParcourirOuest(ref lettre, carte, frontieres, x, y);
}
if (NordOuestSudEst.Item3)
{
Decrypteur.ParcourirSud(ref lettre, carte, frontieres, x, y);
}
if (NordOuestSudEst.Item4)
{
Decrypteur.ParcourirEst(ref lettre, carte, frontieres, x, y);
}
Decrypteur.AppliquerLesLettres(ref carte, NordOuestSudEst,
ref ASCII, lettre, x, y);
}
/// <summary>
/// Décryptage de la trame à l'aide du tableau des frontières
/// </summary>
/// <returns>Tableau 2D de la carte</returns>
/// <param name="carte">carte nulle ('*')</param>
/// <param name="frontieres">Tableau des frontières</param>
private static char[,] DefinirLaCarte(char[,] carte, int[,] frontieres)
{
// Le code ASCII sert à changer de lettre
int y, x, ASCII = 97;
for (y = 0; y < 10; y++)
{
for (x = 0; x < 10; x++)
{
// si c'est une unité de terre on utilise l'algo de
// décryptage pour trouver la lettre, démarche inutile
// dans le cas d'une unité de forêt ou de mer
if (frontieres[y, x] < 32 && frontieres[y, x] >= 0)
{
Decrypteur.AlgorithmeDecryptage(ref carte,
frontieres, x, y, ref ASCII);
}
else if (frontieres[y, x] < 64 && frontieres[y, x] >= 32)
{
carte[y, x] = 'F';
}
else if (frontieres[y, x] >= 64)
{
carte[y, x] = 'M';
}
}
}
return(carte);
}
/// <summary>
/// Parcourir les unités au nord tant qu'il y a un voisin au nord
/// </summary>
/// <param name="lettre">lettre</param>
/// <param name="carte">carte</param>
/// <param name="frontieres">tableau des frontières</param>
/// <param name="x">coordonnées x de l'unité</param>
/// <param name="y">coordonnées y de l'unité</param>
private static void ParcourirNord(ref char lettre, char[,] carte,
int[,] frontieres, int x, int y)
{
(bool, bool, bool, bool)NordOuestSudEst =
Decrypteur.LectureBinaireVoisins(frontieres[y, x]);
if (NordOuestSudEst.Item1)
{
if (carte[y - 1, x] != '*')
{
lettre = carte[y - 1, x];
}
Decrypteur.ParcourirNord(ref lettre, carte, frontieres, x,
y - 1);
}
}
/// <summary>
/// Parcourir les unités à l'est tant qu'il y a un voisin à l'est
/// </summary>
/// <param name="lettre">lettre</param>
/// <param name="carte">carte</param>
/// <param name="frontieres">tableau des frontières</param>
/// <param name="x">coordonnées x de l'unité</param>
/// <param name="y">coordonnées y de l'unité</param>
private static void ParcourirEst(ref char lettre, char[,] carte,
int[,] frontieres, int x, int y)
{
int suivant = x + 1;
(bool, bool, bool, bool)NordOuestSudEst =
Decrypteur.LectureBinaireVoisins(frontieres[y, x]);
if (NordOuestSudEst.Item4)
{
if (carte[y, x + 1] != '*')
{
lettre = carte[y, x + 1];
}
Decrypteur.ParcourirEst(ref lettre, carte, frontieres, suivant,
y);
}
}
/// <summary>
/// Seule méthode publique de la classe, elle permet de décrypter la
/// carte de a à z et de sauvegarder la carte dans un fichier
/// .clair
/// </summary>
/// <param name="chemin">Chemin de la trame .chiffre</param>
/// <param name="nom">Nom de sauvegarde du fichier .clair</param>
/// <param name="destination">Destination de sauvegarde</param>
public static void DecrypterLaTrame(string chemin, string nom,
string destination)
{
// Récupération de la trame sous forme d'une liste
List <string> trame = Decrypteur.LireLaTrame(chemin);
// Suppression des séparateurs ":" et "|"
List <int> frontieres = Decrypteur.FiltrerLaTrame(trame);
// Convertir la liste en un tableau 2D
int[,] frontieresTableau = Decrypteur.ConvertListEnTableau(
frontieres);
// Initialiser un tableau de caractère '*' (ici null)
char[,] tableauNull = Decrypteur.InitialiserTableauNul();
// Récupérer la carte
char[,] carte = Decrypteur.DefinirLaCarte(tableauNull,
frontieresTableau);
// Sauvegarder la carte à l'addresse précisée en paramètres
Decrypteur.SauvegarderLaCarte(nom, destination, carte);
}
