// permet d'analyser la map, pour ensuite exécuter
// l'algorithme A-Star et trouver le chemin
public List <NatNode> FindPath(int startX, int startY, int endX, int endY)
{
// Analyser la map
//nodeMap = new Node[grid.GetLargueur(), grid.GetHauteur()];
NatNode start = grid.GetGridObject(startX, startY);
NatNode goal = grid.GetGridObject(endX, endY);
for (int x = 0; x < grid.GetLargueur(); x++)
{
for (int y = 0; y < grid.GetHauteur(); y++)
{
NatNode node = grid.GetGridObject(x, y);
node.Gcost = int.MaxValue;
node.cameFromNode = null;
node.CalculerFcost();
}
}
// Executer l'algorithme A-Star.
List <NatNode> nodePath = ExecuteAStar(start, goal);
//nodePath.Reverse();
return(nodePath);
}
// Permet de savoir sur quelle node le joueur
// est et de connaitre les informations nécéssaires
// sur la tuile ou le joueur se tient
/*
* private Node FindNode(GameObject obj)
* {
* Collider2D[] collindingObjects = Physics2D.OverlapCircleAll(obj.transform.position, 0.2f);
*
* foreach (Collider2D collidingObject in collindingObjects)
* {
* if (collidingObject.gameObject.GetComponent<Node>() != null)
* {
* // Le joueur est sur cette node
* Node tile = collidingObject.gameObject.GetComponent<Node>();
*
* // Permet de trouver la node qui contient la tuile
* for (int y = 0; y < grid.GetHauteur(); y++)
* {
* for (int x = 0; x < grid.GetLargueur(); x++)
* {
* Node node = nodeMap[x, y];
*
* if (node.cameFromNode == tile)
* {
* return node;
* }
* }
* }
* }
* }
* return null;
* }
*/
// Permet d'exécuter l'algorithme principale,
// qui sert à trouver le chemin le plus cours
// pour attendre le point visé
private List <NatNode> ExecuteAStar(NatNode start, NatNode goal)
{
// Cette list sert à évaluer le potentiel de chaque nodes
// pour faire le meilleur chemin et qui devrait être
// visitée. On commence toujours à l'origine.
List <NatNode> openList = new List <NatNode>()
{
start
};
// Cette liste permet de se souvenir des nodes visitées
List <NatNode> closedList = new List <NatNode>();
// Permet d'initialiser la node initiale
start.Gcost = 0;
start.Hcost = CalculerLaDistanceEntreNode(start, goal);
start.CalculerFcost();
// l'algorithme principale
while (openList.Count > 0)
{
// On regarde au début la node qui à le
// coût estimé le plus bas pour rejoindre
// l'objectif
NatNode current = CalculerLePlusBasF(openList);
// On regarde si l'objectif est atteint
if (current == goal)
{
return(BuilPath(goal));
}
// On s'assure que la node visité ne soit
// pas visité de nouveau
openList.Remove(current);
closedList.Add(current);
// On éxécute l'algorithme dans la node voisine
//List<Node> neighbours = GetNeighnourNodes(current);
foreach (NatNode neighbour in GetNeighnourNodes(current))
{
if (closedList.Contains(neighbour))
{
// Si la node voisine à été visité,
// on l'ignore
continue;
}
if (neighbour.obstacle == true)
{
closedList.Add(neighbour);
continue;
}
// On calcule une nouvelle valeur pour g et on vérifie
// si elle est meilleur que la précédente.
int candidateG = current.Gcost + CalculerLaDistanceEntreNode(current, neighbour);
//int candidateG = current.Gcost + 1;
if (candidateG < neighbour.Gcost)
{
// Sinon, cela veux dire que l'on a trouvé un meilleur chemin
// On initialise les nouvelles valeurs
neighbour.Gcost = candidateG;
neighbour.Hcost = CalculerLaDistanceEntreNode(current, goal);
neighbour.cameFromNode = current;
neighbour.CalculerFcost();
if (!openList.Contains(neighbour))
{
// Si la node n'a pas été visité,
// on peut la considéré comme valide et
// la rajouté dans la liste
openList.Add(neighbour);
}
}
}
}
//Il n'y a pas de chemin
return(null);
}