/// <summary>
/// Cette méthode permet de former la Pioche. Normalement cette méthode est appelé en début de compilation
/// pour crée la pioche du jeu.
/// </summary>
/// <returns></returns>
public List <Lettre> LaPioche() //peupler la pioche
{
string file1 = @"Lettre.txt"; //n'est pas dans le debug
StreamReader Lettres = new StreamReader(file1);
List <Lettre> LaNouvellePioche = new List <Lettre>();
string[] Donnees;
string UneLigne;
while ((UneLigne = Lettres.ReadLine()) != null) //condition d'arret.
{
Donnees = UneLigne.Split(','); //données séparés par des virgules
Lettre UneLettre = new Lettre(char.Parse("a"), 2); //c'est une variable
UneLettre.Symbole = char.Parse(Donnees[0]); //on l'actualise a chaque passage dans la boucle
UneLettre.Poid = int.Parse(Donnees[2]);
for (int j = 0; j < int.Parse(Donnees[1]); j++) //et on l'ajoute pour le nombre de fois ou elle est censé etre dans la pioche
{
LaNouvellePioche.Add(UneLettre);
}
}
Lettres.Close();
//on ajoute deux jokers
Lettre JOKER = new Lettre('§', 0);//mes JOKER sont un peu spéciaux. Je les remarques facilement avec '§'.
LaNouvellePioche.Add(JOKER);
LaNouvellePioche.Add(JOKER);
return(LaNouvellePioche);
}
/// <summary>
/// Otelettre est un verificateur qui m'autorise ou non a poser un mots. Cette methode prends en parametre
/// Le nb de jokers d'un joueur et si il en a. Elle retire les lettres correspondants au mots posé.
/// </summary>
/// <param name="mot"></param>
/// <param name="ContientUnJoker"></param>
/// <param name="NbJokers"></param>
/// <returns></returns>
public bool OteLettre(string mot, bool ContientUnJoker, int NbJokers, string[] Position) //enleve une lettre au joueur.
{
bool result = true;
Lettre var = new Lettre(char.Parse("a"), 0);
int NombreLettresManquantes = 0;
if (ContientUnJoker)
{
for (int i = 0; i < mot.Length; i++)
{
var.Symbole = mot[i];
int index = ListeLettres.FindIndex(x => x.Symbole == mot[i]); //un peu de linq qui m'est tres utile.
if (index > -1)
{
ListeLettres.RemoveAt(index);
}
else
{
NombreLettresManquantes += 1;
int index1 = ListeLettres.FindIndex(x => x.Symbole == '§');
ListeLettres.RemoveAt(index1);
}
if (NombreLettresManquantes > NbJokers)
{
return(false);
}
}
return(true);
}
if (!ContientUnJoker)
{
List <Lettre> LettresEnlevees = new List <Lettre>(); //on remet les lettres si le mot nest pas valide
for (int i = 0; i < mot.Length; i++)
{
int index = ListeLettres.FindIndex(x => x.Symbole == mot[i]); //un peu de linq qui m'est tres utile.
if (index != -1)
{
LettresEnlevees.Add(ListeLettres[index]);
ListeLettres.RemoveAt(index);
}
else if (GrilleMatrice[int.Parse(Position[0]) - 1, int.Parse(Position[1]) - 1].Symbole == mot[i])
{
//La lettre n'est pas dans le plateau du joueur car elle est deja dans la grille.
}
else
{
for (int k = 0; k < LettresEnlevees.Count; k++)
{
ListeLettres.Add(LettresEnlevees[k]);
}
return(false);
}
}
return(result);
}
else
{
return(true);
}
}
public Joueur(string Nom) //constructeur
{
this.Nom = Nom;
Score = 0;
ListeLettres = new List <Lettre>();
ListeMotsTrouves = new List <string>();
this.GrilleMatrice = new Lettre[10, 10]; //on sait que la matrice est une 10,10
//on doit instancier la mtrice. Je rempli donc la matrice d'espaces.
//ses lettres vides seront remplacés quand on posera un mots.
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
Lettre UneLettre = new Lettre(' ', 0);
GrilleMatrice[i, j] = UneLettre;
}
}
}
/// <summary>
/// Si on veut poser un mots on passe par cette méthode qui verifie si le mots est un mots du dico
/// si celui ci est un motscroisée valable
/// si les lettres correpondantes au mots sont des lettre du joueur.
/// </summary>
/// <param name="mots"></param>
/// <param name="Position"></param>
/// <param name="UnMot"></param>
/// <param name="Jeu1"></param>
/// <param name="r"></param>
public void PoserUnMot(string mots, string[] Position, MotsCroises UnMot, Jeu Jeu1, Random r) //a partir de l'entree mettre une lettre dans la grille.
{
Lettre JOKER = new Lettre('§', 0); //C'est mon joker
bool ContientUnJoker = false;
string NouveauMots = "";
int NbJokers = 0;
for (int o = 0; o < 2; o++) //au cas ou la personne ait 2 jokers On verfie Deux fois
{
for (int l = 0; l < mots.Length; l++)
{
if (mots[l] == '(') //si j'utilises un joker je mets des () autour de la lettre remplacée
{
if (mots[l + 2] == ')')
{
for (int z = 0; z < mots.Length; z++) //il y a un joker
{
if (z != l && z != l + 2) //on reforme le mots sans les ().
{
NbJokers += 1;
ContientUnJoker = true;
NouveauMots += mots[z];
}
}
mots = NouveauMots; //pour ne pas avoir les ().
}
}
}
} // on verfie les Jokers
if (ContientUnJoker)
{
mots = NouveauMots;
}
UnMot.MotsGrille.Add(mots);
//une fonction pour verifier que le mot est bon
bool result = OteLettre(mots, ContientUnJoker, NbJokers, Position); //3 verifications ici.
if (UnMot.EstUnMotCroisee(mots, Position) && UnMot.EstUnMotDuDictionnaire() && result)
{
int poid; //correspond au poid de la lettre en question
int PoidMots = 0; //corresponds poid du mots
Console.WriteLine("le mots est " + mots);
for (int i = 0; i < mots.Length; i++)
{
if (mots[i] == 'X' || mots[i] == 'Y' || mots[i] == 'Z' || mots[i] == 'W' || mots[i] == 'K')
{
poid = 5;
}
else
{
poid = 0;
}
Lettre UneLettre = new Lettre(mots[i], poid);
PoidMots += poid;
if (Position[2].ToUpper() == "H")//on pose le mots sur la grille
{
GrilleMatrice[int.Parse(Position[0]) - 1, int.Parse(Position[1]) - 1 + i] = UneLettre;
}
if (Position[2].ToUpper() == "V")
{
GrilleMatrice[int.Parse(Position[0]) - 1 + i, int.Parse(Position[1]) - 1] = UneLettre;
}
}
Console.WriteLine($"Le poid du mot est {PoidMots}");
List <string> Mots = new List <string>();
Mots.Add(mots);
ListeMotsTrouves.Add(mots);
CalculScore();
}
else
{
Console.WriteLine("ERREUR => NON POSSIBLE"); //une des 3 verifications a renvoyé false
UnMot.MotsGrille.Remove(mots); //on actualise
ListeMotsTrouves.Remove(mots);
}
Add_Lettres(2, Jeu1.LaPioche, r); //un tour est effectué, on ajoute deux lettre au joueur en cours
Console.WriteLine($"Nouveau Score = {this.Score}");
//si le mots est valable
AfficherGrille();
}
