static void Main(string[] args)
{
GraphGenerator gl = new GraphGenerator(20, 20, 15);
displayArrayBool(gl.tabInitial);
Console.WriteLine("Nombre Total de Noeud : " + gl.graph.Count);
foreach (KeyValuePair <Coordonnee, List <Vecteur> > obj in gl.graph)
{
Console.WriteLine("Le point X=" + obj.Key.x + " , Y=" + obj.Key.y);
foreach (Vecteur vec in obj.Value)
{
Console.WriteLine("Est relier au point X=" + vec.coor.x + " , Y=" + vec.coor.y + " avec une pondération de " + vec.ponderation);
}
Console.WriteLine();
}
Pathfinding dif = new Pathfinding();
Chemin path = dif.Chemin_Le_Plus_Cours(
new Coordonnee()
{
x = 0, y = 0
},
new Coordonnee()
{
x = 15, y = 10
},
gl.graph
);
if (path == null)
{
Console.WriteLine("Le path est null test");
}
else
{
foreach (Coordonnee coor in path.listeCoor)
{
Console.WriteLine("Point : X=" + coor.x + " , Y=" + coor.y);
}
}
Console.ReadLine();
}
private void PrintChemin(Chemin chemin)
{
for (int i = 0; i < chemin.listeVilles.Count - 1; i++)
{
Line line = new Line();
line.Stroke = SystemColors.WindowFrameBrush;
line.X1 = chemin.listeVilles[i].XVille;
line.Y1 = chemin.listeVilles[i].YVille;
line.X2 = chemin.listeVilles[i + 1].XVille;
line.Y2 = chemin.listeVilles[i + 1].YVille;
cheminLines.Add(line);
canvasImageCarte.Children.Add(line);
}
}
/// <summary>
/// Calcule le chemin (prenant en compte les obstacles) pour aller d'un point à un autre
/// </summary>
/// <param name="oDepart">Coordonnee de depart</param>
/// <param name="oArrivee">coordonnee d'arrivee</param>
/// <returns>Chemin à emprunter pour y arriver</returns>
public Chemin CalculerChemin(Coordonnees oDepart, Coordonnees oArrivee)
{
Chemin c = new Chemin();
int a = oDepart.x;
int b = oArrivee.x;
int cpt = oDepart.x;
//todo : prendre en compte les obstacles
int diff;
if (a != b)
{
diff = (b - a) / Math.Abs(b - a);
//diff : operateur de difference, si xDep<Xarr, diff = 1, et vice versa, idem pour y
//tant que le compteur sur x n'est pas egale à la valeur x d'arrivée
while (cpt != b)
{
cpt += diff;
c.AddMouvementFin(new Vecteur(diff, 0));
}
//ici, on a comblé la diff sur X
}
a = oDepart.y;
b = oArrivee.y;
if (a != b)
{
diff = (b - a) / Math.Abs(b - a);
cpt = oDepart.y;
while (cpt != b)
{
cpt += diff;
c.AddMouvementFin(new Vecteur(0, diff));
}
}
//ajout du premier vecteur, nul pour initialiser le deplacement du sprite dans al bonne direction
if (c.TailleParcours > 0)
{
c.AddMouvementDebut(Vecteur.Zero);
}
Console.WriteLine("Chemin calculé pour aller de " + oDepart + " à " + oArrivee + " : ");
Console.WriteLine(c.ToString());
return c;
}
// dessiner chemin apres la fin du traitement pour montrer le plus petit chemin
private void DessinerChemin(Chemin c)
{
for (int i = 0; i < c.MesVilles.Count() - 1; i++)
{
Ville v1 = c.MesVilles[i];
Ville v2 = c.MesVilles[i + 1];
var uneLigne = new Line
{
X1 = v1.XVille,
Y1 = v1.YVille,
X2 = v2.XVille,
Y2 = v2.YVille,
Stroke = new SolidColorBrush(Colors.Red),
StrokeThickness = 2
};
canvas_carte.Children.Add(uneLigne);
}
}
public static int[] Generateur(int x, int y)
{
//Création des variables
int[] Plan = new int[x * y];
int a = 0;
while (a < Plan.Length)
{
Plan[a] = -1;
a += 1;
}
int Case = 0;
int n = 0;
int CaseRemplies = 0;
int CaseActuelle = 0;
int CaseCible = 0;
int[] Directions = { 0, 0, 0, 0 };
int Precedent = -1;
List <int> Chemin = new List <int>();
//Tant que toutes les cases n'ont pas été connectées à d'autres, on continue de créer des voies.
while (CaseRemplies < Plan.Length)
{
//Si on n'est pas sur la première case, on choisit une case encore inexplorée et on la connecte directement aux chemins déjà formés.
while (CaseRemplies < Plan.Length - 1 && Plan[CaseRemplies] != -1)
{
CaseRemplies += 1;
}
if (CaseRemplies > 0)
{
if (CaseRemplies < x)
{
Plan[CaseRemplies - 1] -= 2;
}
else
{
if (Plan[CaseRemplies - x] % 2 == 1)
{
Plan[CaseRemplies - x] -= 1;
}
}
}
if (CaseRemplies < Plan.Length - 1)
{
//On crée un nouveau trajet. Le trajet prend fin jusqu'à rencontrer une case déjà visitée ou ne plus pouvoir se déplacer ; il ne peut pas repasser deux fois par la meme case.
Plan[CaseRemplies] = 3;
CaseActuelle = CaseRemplies;
Chemin = new List <int> {
CaseActuelle
};
n += 1;
Precedent = -1;
int Distance = 0;
while (CaseActuelle > -1)
{
Directions = Aleatoire(4, 4);
bool valide = false;
int analysea = 0;
//A chaque case du trajet, on choisit un ordre de priorité pour les directions. On choisit alors la direction prioritaire possible (ne sont pas possibles les directions qui mènent sur une case du trajet ou qui sortent des limites du dédale).
while (!valide && analysea < 4)
{
if ((Directions[analysea] == 0 && CaseActuelle % x == x - 1) ||
(Directions[analysea] == 1 && CaseActuelle >= x * (y - 1)) ||
(Directions[analysea] == 2 && CaseActuelle % x == 0) ||
(Directions[analysea] == 3 && CaseActuelle < x) ||
Directions[analysea] == (Precedent + 2) % 4)
{
analysea += 1;
}
else
{
valide = true;
CaseCible = CaseActuelle + (new int[] { 1, x, -1, -x })[Directions[analysea]];
int analyseb = 0;
;
while (valide && analyseb < Chemin.Count)
{
if (CaseCible == Chemin[analyseb])
{
valide = false;
}
analyseb += 1;
}
if (!valide)
{
analysea += 1;
}
else
{
//La case est valide, on rajoute alors le chemin pour la connecter au trajet. Et on recommence sur la nouvelle case, jusqu'à tomber sur une case déjà ouverte ou ne plus pouvoir se déplacer.
analysea = Directions[analysea];
Precedent = analysea;
int modif = 2 - (analysea % 2);
if (analysea < 2)
{
analysea = CaseActuelle;
}
else
{
analysea = CaseCible;
}
if (Plan[CaseCible] == -1)
{
Distance += 1;
if (Distance == x + y)
{
Chemin = new List <int>();
Distance = 0;
}
Plan[CaseCible] = 3;
Plan[analysea] -= modif;
CaseActuelle = CaseCible;
Chemin.Add(CaseActuelle);
analysea = 0;
}
else
{
if (Plan[analysea] == 3 || Plan[analysea] == modif)
{
Plan[analysea] -= modif;
}
CaseActuelle = -1;
}
}
}
}
if (analysea == 4)
{
CaseActuelle = -1;
}
}
}
else
{
Plan[CaseRemplies] = 3;
if (CaseRemplies != x * y - 1)
{
Plan[CaseRemplies] = 4;
}
CaseRemplies += 1;
}
}
//Ici, on a déjà un Dédale convenable. Mais on peut parfaitement trouver des configurations de "piliers"... Les lignes suivantes permettent de dédecter les piliers et colmatent l'un des quatre murs (aléatoirement, bien sur).
Case = 0;
while (Case < y - 1)
{
a = 0;
while (a < x - 1)
{
if (Plan[Case * x + a] == 0 && Plan[Case * x + a + 1] % 2 == 0 && Plan[(Case + 1) * x + a] < 2)
{
int b = Random.Range(0, 3);
if (b == 0)
{
Plan[Case * x + a] += 2;
}
if (b == 1)
{
Plan[Case * x + a] += 1;
}
if (b == 2)
{
Plan[Case * x + a + 1] += 1;
}
if (b == 3)
{
Plan[(Case + 1) * x + a] += 2;
}
}
a += 1;
}
Case += 1;
}
//J'ai également pensé à ce petit dédale. Il est déjà défini, il faudra juste effectuer un changement de variables si l'on veut le retourner. Ce sera pratique pour les tests...
int[] Planf = new int[] { 0, 2, 0, 1, 3, 3, 0, 3, 1, 2, 0, 2, 0, 0, 3, 2, 1, 3, 2, 2, 1, 1, 3, 1, 3 };
return(Plan);
}
