internal static int ChoisirPieceIA(int[] piecesJouables, int[,] plateau, int[][] piecesCalcul, string[] piecesRep)
{
int pieceChoisie = -1;
for (int i = 0; i < 16; i++)
{
if (piecesJouables[i] != -1)
{
if (TrouverPos(i, plateau, piecesCalcul) == -1)
{
pieceChoisie = i;
break;
}
}
}
if (pieceChoisie == -1)
{
pieceChoisie = ChoisirPiece(piecesJouables, piecesRep);
}
else
{
IHM.AfficherChoixOrdi(pieceChoisie, piecesRep);
piecesJouables[pieceChoisie] = -1;
}
return(pieceChoisie);
}
static void Main(string[] args)
{
IHM ihm = new IHM();
ihm.Start();
Console.ReadLine();
}
protected ISolution bestSoFarSolution; // Meilleur solution trouvée jusque là.
public override sealed void Solve(IProblem _pb, IHM _ihm)
{
base.Solve(_pb, _ihm);
currentSolution = pb.RandomSolution(); // Solution aléatoire du Probleme : Solution initiale.
bestSoFarSolution = currentSolution;
AddToTabuList(currentSolution); // Etant donné quelle est visitée elle est tabou.
while (!Done())
// indique si oui ou non les critères d’arrêt sont atteints.
{
List <ISolution> Neighbours = pb.Neighbourhood(currentSolution);
// Liste des solutions voisines.
if (Neighbours != null)
// Existe il des voisins?
{
Neighbours = RemoveSolutionsInTabuList(Neighbours);
// les solutions présentes dans la liste des positions taboues sont enlevées pour ne pas parcourir les mmes solutions.
ISolution bestSolution = pb.BestSolution(Neighbours);
// Meilleur solution parmi les solutions voisines de la solution courante.
if (bestSolution != null)
{ // Car la meilleur solution pouvait etre considéré comme tabou.
UpdateSolution(bestSolution);
// C’est dans cette méthode que bestSoFarSolution est utilisée.
}
}
Increment();
}
SendResult();
}
static void Main(string[] args)
{
int choixPrinc;
do
{
Console.Clear();
Console.WriteLine("Bievenue dans votre menu libraire zbrrrrrr");
Console.WriteLine("1- Se connecter");
Console.WriteLine("0- Quitter");
Int32.TryParse(Console.ReadLine(), out choixPrinc);
switch (choixPrinc)
{
case 1:
Personne p = IHM.Connection();
Console.Clear();
switch (p.UserType)
{
case UserTypes_Enum.admin:
IHM.MenuPrincipalAdmin();
break;
default:
IHM.MenuBookOther();
break;
}
break;
default:
break;
}
} while (choixPrinc != 0);
}
int maxIterations = 10001; // Le nombre maximal d’itérations a été atteint, et on s’arrête donc.
public NeuralSystem(int _nbInputs, int _nbHidden, int _nbOutputs, String[] _data, double _trainingRatio, IHM _ihm)
{
// Constructeur.
data = new DataCollection(_data, _nbOutputs, _trainingRatio);
network = new NeuralNetwork(_nbInputs, _nbHidden, _nbOutputs);
ihm = _ihm;
}
protected const int NB_INDIVIDUALS = 30; // le nombre d’individus utilisés dans notre population.
public override sealed void Solve(IProblem _pb, IHM _ihm)
{
base.Solve(_pb, _ihm);
// Creation de la liste de solutions courante : Population.
currentSolutions = new List <ISolution>();
for (int i = 0; i < NB_INDIVIDUALS; i++)
{
ISolution newSolution = pb.RandomSolution();
currentSolutions.Add(newSolution);
}
bestActualSolution = pb.BestSolution(currentSolutions);
// Meilleure solution actuelle au sein de la population.
bestSoFarSolution = bestActualSolution;
// Meilleure solution rencontrée jusqu’alors.
while (!Done()) // indique si oui ou non les critères d’arrêt sont atteints.
{
UpdateGeneralVariables(); // Mise à jour des meilleures solutions globales.
UpdateSolutions(); // Mise à jour des positions des solutions.
Increment(); // Incrementation des variables pour les critères d'arrets.
}
SendResult();
}
static void Main(string[] args)
{
Console.OutputEncoding = Encoding.UTF8;
IHM ihm = new IHM();
ihm.Start();
Console.ReadLine();
}
internal static string JeuxJvO(int[,] plateau, int[] piecesJouables, int tour, int[][] piecesCalcul, int niveaux, string[] piecesRep)
{
bool type = true;
int caseCourante = -1;
int pieceCourante = -1;
IHM.AfficherEcranJeux(plateau, piecesJouables, piecesRep, caseCourante, pieceCourante);
string etat = "JEUX";
bool gagner = false;
//============================================================================================================
// Départ de la Boucle de jeux pour un Player vs Ordi
//============================================================================================================
bool sauvegarde = false;
int[] piecesVides = new int[] { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
while (!gagner)
{
if (piecesJouables.SequenceEqual(piecesVides))
{
IHM.AfficherEgalite();
}
IHM.AfficherInfoTour(tour, false, niveaux);
// Tour de l'ordinateur
if (tour % 2 == 0)
{
IHM.AfficherConseil(0);
int idPiece = ChoisirPiece(piecesJouables, sauvegarde, plateau, tour, type, piecesRep);
IHM.AfficherEcranJeux(piecesJouables, piecesRep);
sauvegarde = IA.PoserPieceIA(out int position, idPiece, plateau, piecesCalcul);
IHM.AfficherEcranJeux(plateau, piecesRep);
IHM.AfficherConseil(6);
gagner = TesterVictoire(idPiece, position, plateau, piecesCalcul);
if (gagner)
{
etat = "PERDU";
}
}
// Tour du joueur
else
{
int idPiece = IA.ChoisirPieceIA(piecesJouables, plateau, piecesCalcul, piecesRep);
sauvegarde = false;
IHM.AfficherConseil(1);
IHM.AfficherEcranJeux(piecesJouables, piecesRep);
sauvegarde = PoserPiece(out int position, idPiece, plateau, sauvegarde, piecesJouables, tour, type, piecesRep);
IHM.AfficherEcranJeux(plateau, piecesRep);
IHM.AfficherConseil(6);
gagner = TesterVictoire(idPiece, position, plateau, piecesCalcul);
if (gagner)
{
etat = "GAGNER";
}
}
tour++;
}
return(etat);
}
internal static int ChoisirPiece(int[] piecesJouables, string[] piecesRep)
{
int pieceChoisie = rn.Next(0, 16);
while (piecesJouables[pieceChoisie] == -1)
{
pieceChoisie = rn.Next(0, 16);
}
IHM.AfficherChoixOrdi(pieceChoisie, piecesRep);
piecesJouables[pieceChoisie] = -1;
return(pieceChoisie);
}
internal static bool PoserPiece(out int position, int idPiece, int[,] plateau)
{
int caseChoisie = rn.Next(0, 16);
Utilisables.Pos2Coord(out int x, out int y, caseChoisie);
while (plateau[x, y] >= 0)
{
caseChoisie = rn.Next(0, 16);
Utilisables.Pos2Coord(out x, out y, caseChoisie);
}
plateau[x, y] = idPiece;
IHM.AfficherCaseOrdi(x, y);
position = caseChoisie;
return(false);
}
static void Main(string[] args)
{
Personne p = IHM.Connection();
Console.Clear();
switch (p.UserType)
{
case UserTypes_Enum.admin:
IHM.MenuPrincipalAdmin();
break;
default:
IHM.MenuBookOther();
break;
}
}
internal static bool PoserPieceIA(out int position, int idPiece, int[,] plateau, int[][] piecesCalcul)
{
int x, y;
position = TrouverPos(idPiece, plateau, piecesCalcul);
if (position == -1)
{
PoserPiece(out position, idPiece, plateau);
}
else
{
Utilisables.Pos2Coord(out x, out y, position);
plateau[x, y] = idPiece;
IHM.AfficherCaseOrdi(x, y);
}
return(false);
}
public override bool Process()
{
String theReadLine = null;
Console.Write("Please enter your calcul \n");
theReadLine = Console.ReadLine();
Console.Write("You write the following line " + theReadLine + " \n");
if (!IHM.YorNoDialog("Do You Want to process the Calcul ?"))
{
return(false);
}
Main_Calcul theCalcul = new Main_Calcul(CreateLine(theReadLine), ref mVarList);
Program.DebugMessage("Process of the IHM Manual Function\n");
return(theCalcul.Calculate());
}
public override sealed void Solve(IProblem _pb, IHM _ihm)
{
base.Solve(_pb, _ihm);
currentSolution = pb.RandomSolution();
// La solution aléatoire du probleme.
while (!Done())
// indique si oui ou non les critères d’arrêt sont atteints.
{
List <ISolution> Neighbours = pb.Neighbourhood(currentSolution);
// Liste des solutions voisines.
if (Neighbours != null)
// Existe il des voisins.
{
ISolution bestSolution = pb.BestSolution(Neighbours);
// Meilleur solution parmi les solutions voisines de la solution courante.
UpdateSolution(bestSolution);
// Change ou non la meilleur solution, selon la présence ou l’absence d’une amélioration.
}
Increment();
}
SendResult();
}
// La temperature. permettant de calculer la probabilité de validation d'une soution. P = e(-AE/T).
public override sealed void Solve(IProblem _pb, IHM _ihm)
{
base.Solve(_pb, _ihm);
currentSolution = pb.RandomSolution(); // Solution aléatoire du Probleme : Solution initiale.
bestSoFarSolution = currentSolution;
InitTemperature(); // Initialisation de la temperature.
while (!Done()) // indique si oui ou non les critères d’arrêt sont atteints.
{
List <ISolution> Neighbours = pb.Neighbourhood(currentSolution);
// Liste des solutions voisines.
if (Neighbours != null) // // Existe il des voisins?
{
ISolution bestSolution = pb.BestSolution(Neighbours);
// Meilleur solution parmi les solutions voisines de la solution courante.
UpdateSolution(bestSolution);
// C’est dans cette méthode que la température et bestSoFarSolution sont utilisées.
}
Increment();
UpdateTemperature();
}
SendResult();
}
static void Main(string[] args)
{
IHM ihm = new IHM();
ihm.Demarrer();
}
public NeuralSystem(int nbInput, int nbHidden, int nbOutput, String[] strData, double trainingRatio, IHM pihm)
{
data = new DataCollection(strData, nbOutput, trainingRatio);
network = new NeuralNetwork(nbInput, nbHidden, nbOutput);
ihm = pihm;
}
public Dijkstra(Graph _graph, IHM _ihm) : base(_graph, _ihm)
{
}
public Moteur(IHM ihm)
{
_ihm = ihm;
_bdFaits = new BaseFaits();
_bdRegles = new BaseRegles();
}
static void Main(string[] args)
{
IHM ihm = new IHM();
ihm.Start();
}
public BellmanFord(Graph _graph, IHM _ihm) : base(_graph, _ihm)
{
}
public BreadthFirst(Graph _graph, IHM _ihm) : base(_graph, _ihm)
{
}
public static void Main(string[] args)
{
//Utilisables.JouerMusiqueIntro();
int[,] plateau = new int[4, 4]; // variable représentant l'état du plateu de jeux pendant la partie
int[] piecesJouables = new int[16]; // variable contenant l'identifiant des pieces encore disponibles
//int[] piecesJouees = new int[16]; // variable contenant l'identifiant des pieces déjà placées sur le plateau
IHM.InitialiserGraphiques();
IHM.AfficherIntro();
//============================================================================================================
// Affichage du menu principal du jeu
//============================================================================================================
int boutonCourantMenu = 1; // Initialisation du bouton courant du menu
bool menu = true;
// Boucle permettant d'afficher le menu de manière interactive
while (menu)
{
IHM.AfficherMenu(boutonCourantMenu);
System.ConsoleKeyInfo Bouton = Console.ReadKey();
switch (Bouton.Key)
{
case ConsoleKey.LeftArrow:
case ConsoleKey.UpArrow:
boutonCourantMenu = (boutonCourantMenu -= 1) % 3;
break;
case ConsoleKey.RightArrow:
case ConsoleKey.DownArrow:
boutonCourantMenu = (boutonCourantMenu += 1) % 3;
break;
case ConsoleKey.Enter:
if (boutonCourantMenu == 2)
{
Environment.Exit(0); // Bouton Quitter
}
else if (boutonCourantMenu == 1)
{
menu = false; // Bouton Jouer
}
else
{
Console.Clear(); IHM.AfficherRegles();
} // Bouton Règles
break;
}
/*// Définition des touches permettants de parcourir les boutons du menu
* if (Bouton.Key == ConsoleKey.LeftArrow) boutonCourantMenu = (boutonCourantMenu -= 1) % 3;
* else if (Bouton.Key == ConsoleKey.RightArrow) boutonCourantMenu = (boutonCourantMenu += 1) % 3;
*
* // Action à réaliser quand un bouton est selectionné
* else if (Bouton.Key == ConsoleKey.Enter)
* {
* if (boutonCourantMenu == 2) Environment.Exit(0); // Bouton Quitter
* else if (boutonCourantMenu == 1) menu = false; // Bouton Jouer
* else { Console.Clear(); IHM.AfficherRegles(); } // Bouton Règles
* }*/
if (boutonCourantMenu < 0)
{
boutonCourantMenu = Math.Abs(boutonCourantMenu + 3); // Permet de réaliser le "modulo négatif"
}
}
bool jouer = true;
while (jouer)
{
//============================================================================================================
// Affichage du menu de chargement de partie
//============================================================================================================
int BoutonChargerCourant = 1;
bool nouveauJeux = true;
bool charger = false;
while (nouveauJeux) // Menu de jeu, charger, nouvelle partie
{
IHM.AfficherEcranChargement(BoutonChargerCourant);
System.ConsoleKeyInfo Bouton = Console.ReadKey();
switch (Bouton.Key)
{
case ConsoleKey.LeftArrow:
case ConsoleKey.UpArrow:
BoutonChargerCourant = (BoutonChargerCourant -= 1) % 2;
break;
case ConsoleKey.RightArrow:
case ConsoleKey.DownArrow:
BoutonChargerCourant = (BoutonChargerCourant += 1) % 2;
break;
case ConsoleKey.Enter:
if (BoutonChargerCourant == 0)
{
nouveauJeux = false;
}
else
{
charger = true;
nouveauJeux = false;
}
break;
}
/*
* if (Bouton.Key == ConsoleKey.LeftArrow) BoutonChargerCourant = (BoutonChargerCourant -= 1) % 2;
* else if (Bouton.Key == ConsoleKey.RightArrow) BoutonChargerCourant = (BoutonChargerCourant += 1) % 2;
* else if (Bouton.Key == ConsoleKey.Enter)
* {
* if (BoutonChargerCourant == 0) nouveauJeux = false;
* else
* {
* charger = true;
* nouveauJeux = false;
* }
* }
*/
//BoutonChargerCourant = BoutonChargerCourant < 0 ? Math.Abs(BoutonChargerCourant + 2) % 2 : BoutonChargerCourant;
if (BoutonChargerCourant < 0)
{
BoutonChargerCourant = Math.Abs(BoutonChargerCourant + 2);
}
}
//============================================================================================================
string nomFichier = "../../Sauvegardes\\Z_NouvellePartie.txt";
//============================================================================================================
// Création de la partie chargée ou non
//============================================================================================================
if (charger == true) // Si on charge un sauvegarde
{
nomFichier = IHM.AfficherPageChargement();
}
// Initialisation du tableau et des pieces pour la partie
Utilisables.InitialiserPartie(nomFichier, ref plateau, ref piecesJouables);
IHM.InitialiserEcranJeux();
int caseCourante = -1;
int pieceCourante = -1;
IHM.AfficherEcranJeux(plateau, piecesJouables, caseCourante, pieceCourante);
int tour = 0;
bool gagner = false;
//============================================================================================================
// Départ de la Boucle de jeux pour un Player vs Ordi
//============================================================================================================
bool sauvegarde = false;
bool joueur = true;
int[] piecesVides = new int[] { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
while (!gagner)
{
if (piecesJouables.SequenceEqual(piecesVides))
{
IHM.AfficherEgalite();
}
// Tour de l'ordinateur
if (tour % 2 == 0)
{
int idPiece = Utilisables.ChoisirPiece(piecesJouables, sauvegarde, plateau);
IHM.AfficherEcranJeux(piecesJouables);
sauvegarde = IA.PoserPiece(out int position, idPiece, plateau);
IHM.AfficherEcranJeux(plateau);
gagner = Utilisables.TesterVictoire(idPiece, position, plateau);
}
// Tour du joueur
else
{
int idPiece = IA.ChoisirPiece(piecesJouables);
sauvegarde = false;
IHM.AfficherEcranJeux(piecesJouables);
sauvegarde = Utilisables.PoserPiece(out int position, idPiece, plateau, sauvegarde, piecesJouables);
IHM.AfficherEcranJeux(plateau);
gagner = Utilisables.TesterVictoire(idPiece, position, plateau);
if (gagner)
{
joueur = false;
}
}
tour++;
}
//IHM.AnimationVictoire();
IHM.AfficherEcranVictoire(joueur);
jouer = IHM.AfficherRejouer();
}
//Console.Read();
}
internal static int ChoisirPiece(int[] piecesJouables, bool sauvegarde, int[,] plateau, int tour, bool type, string[] piecesRep)
{
bool choix = false;
int indice = -1;
int pieceCourante = 0;
while (indice == -1)
{
indice = piecesJouables[pieceCourante];
if (piecesJouables[pieceCourante] < 0)
{
pieceCourante++;
}
}
Pos2Coord(out int ligneCourante, out int colonneCourante, pieceCourante);
IHM.AfficherEcranJeux(piecesJouables, piecesRep, pieceCourante);
while (!choix)
{
bool pause = false;
System.ConsoleKeyInfo mouvement = Console.ReadKey();
switch (mouvement.Key)
{
case ConsoleKey.Q:
case ConsoleKey.LeftArrow:
colonneCourante = (colonneCourante -= 1) % 4;
break;
case ConsoleKey.D:
case ConsoleKey.RightArrow:
colonneCourante = (colonneCourante += 1) % 4;
break;
case ConsoleKey.Z:
case ConsoleKey.UpArrow:
ligneCourante = (ligneCourante -= 1) % 4;
break;
case ConsoleKey.DownArrow:
case ConsoleKey.S:
ligneCourante = (ligneCourante += 1) % 4;
break;
case ConsoleKey.Spacebar:
case ConsoleKey.Enter:
if (piecesJouables[pieceCourante] != -1)
{
piecesJouables[pieceCourante] = -1;
choix = true;
sauvegarde = false;
}
break;
case ConsoleKey.P:
sauvegarde = IHM.AfficherMenuPause(sauvegarde, plateau, piecesJouables, tour, type);
pause = true;
break;
case ConsoleKey.Escape:
if (sauvegarde)
{
Environment.Exit(0);
}
else
{
IHM.AfficherQuitter(plateau, piecesJouables, piecesRep, -1, pieceCourante);
}
break;
}
if (colonneCourante < 0)
{
colonneCourante = Math.Abs(colonneCourante + 4);
}
if (ligneCourante < 0)
{
ligneCourante = Math.Abs(ligneCourante + 4);
}
pieceCourante = Coor2Pos(ligneCourante, colonneCourante);
//if(piecesJouables[pieceCourante] >= 0)
if (pause)
{
IHM.AfficherEcranJeux(plateau, piecesJouables, piecesRep, -1, pieceCourante);
IHM.AfficherInfoTour(tour);
}
else
{
IHM.AfficherEcranJeux(piecesJouables, piecesRep, pieceCourante);
}
}
return(pieceCourante);
}
public Algorithm(Graph _graph, IHM _ihm)
{
graph = _graph;
ihm = _ihm;
}
public AStar(Graph _graph, IHM _ihm) : base(_graph, _ihm)
{
}
internal static int ChoisirPiece(int[] piecesJouables, bool sauvegarde, int[,] plateau)
{
bool choix = false;
int colonneCourante = 0;
int ligneCourante = 0;
int indice = -1;
int pieceCourante = 0;
while (indice == -1)
{
indice = piecesJouables[pieceCourante];
if (piecesJouables[pieceCourante] < 0)
{
pieceCourante++;
}
}
IHM.AfficherEcranJeux(piecesJouables, pieceCourante);
while (!choix)
{
bool pause = false;
System.ConsoleKeyInfo mouvement = Console.ReadKey();
if (mouvement.Key == ConsoleKey.LeftArrow)
{
colonneCourante = (colonneCourante -= 1) % 4;
}
else if (mouvement.Key == ConsoleKey.RightArrow)
{
colonneCourante = (colonneCourante += 1) % 4;
}
else if (mouvement.Key == ConsoleKey.UpArrow)
{
ligneCourante = (ligneCourante -= 1) % 4;
}
else if (mouvement.Key == ConsoleKey.DownArrow)
{
ligneCourante = (ligneCourante += 1) % 4;
}
else if (mouvement.Key == ConsoleKey.Enter && piecesJouables[pieceCourante] != -1)
{
piecesJouables[pieceCourante] = -1;
choix = true;
sauvegarde = false;
}
else if (mouvement.Key == ConsoleKey.P)
{
sauvegarde = IHM.AfficherMenuPause(sauvegarde, plateau, piecesJouables);
pause = true;
}
else if (mouvement.Key == ConsoleKey.Escape && sauvegarde == true)
{
Environment.Exit(0);
}
else if (mouvement.Key == ConsoleKey.Escape && sauvegarde == false)
{
IHM.AfficherQuitter(plateau, piecesJouables, -1, pieceCourante);
}
if (colonneCourante < 0)
{
colonneCourante = Math.Abs(colonneCourante + 4) % 4;
}
if (ligneCourante < 0)
{
ligneCourante = Math.Abs(ligneCourante + 4) % 4;
}
pieceCourante = Coor2Pos(ligneCourante, colonneCourante);
//if(piecesJouables[pieceCourante] >= 0)
if (pause)
{
IHM.AfficherEcranJeux(plateau, piecesJouables, -1, pieceCourante);
}
else
{
IHM.AfficherEcranJeux(piecesJouables, pieceCourante);
}
}
return(pieceCourante);
}
internal static bool PoserPiece(out int position, int idPiece, int[,] plateau, bool sauvegarde, int[] piecesJouables)
{
bool choix = false;
int colonneCourante = 0;
int ligneCourante = 0;
int caseCourante = 0;
int indice = 0;
Utilisables.Pos2Coord(out int x, out int y, indice);
while (plateau[x, y] != -1)
{
indice++;
Utilisables.Pos2Coord(out x, out y, indice);
if (plateau[x, y] == -1)
{
caseCourante = indice;
}
}
Utilisables.Pos2Coord(out ligneCourante, out colonneCourante, caseCourante);
IHM.AfficherEcranJeux(plateau, caseCourante);
while (!choix)
{
bool pause = false;
System.ConsoleKeyInfo mouvement = Console.ReadKey();
if (mouvement.Key == ConsoleKey.LeftArrow)
{
colonneCourante = (colonneCourante -= 1) % 4;
}
else if (mouvement.Key == ConsoleKey.RightArrow)
{
colonneCourante = (colonneCourante += 1) % 4;
}
else if (mouvement.Key == ConsoleKey.UpArrow)
{
ligneCourante = (ligneCourante -= 1) % 4;
}
else if (mouvement.Key == ConsoleKey.DownArrow)
{
ligneCourante = (ligneCourante += 1) % 4;
}
else if (mouvement.Key == ConsoleKey.Enter && plateau[ligneCourante, colonneCourante] == -1)
{
plateau[ligneCourante, colonneCourante] = idPiece;
choix = true;
sauvegarde = false;
IHM.EffacerChoixOrdi();
}
else if (mouvement.Key == ConsoleKey.P)
{
sauvegarde = IHM.AfficherMenuPause(sauvegarde, plateau, piecesJouables);
pause = true;
}
else if (mouvement.Key == ConsoleKey.Escape && sauvegarde == true)
{
Environment.Exit(0);
}
else if (mouvement.Key == ConsoleKey.Escape && sauvegarde == false)
{
IHM.AfficherQuitter(plateau, piecesJouables, caseCourante, -1, idPiece);
}
if (colonneCourante < 0)
{
colonneCourante = Math.Abs(colonneCourante + 4) % 4;
}
if (ligneCourante < 0)
{
ligneCourante = Math.Abs(ligneCourante + 4) % 4;
}
caseCourante = Coor2Pos(ligneCourante, colonneCourante);
if (pause)
{
IHM.AfficherEcranJeux(plateau, piecesJouables, caseCourante);
IHM.AfficherChoixOrdi(idPiece);
}
else
{
IHM.AfficherEcranJeux(plateau, caseCourante);
}
}
position = caseCourante;
return(sauvegarde);
}
public DepthFirst(Graph _graph, IHM _ihm) : base(_graph, _ihm)
{
}
static void Main(string[] args)
{
IHM.LePendu();
}
protected IHM ihm; // Resultat de l'algorithme.
public virtual void Solve(IProblem _pb, IHM _ihm) // Resolution de l'algorithme.
{
pb = _pb;
ihm = _ihm;
}