// 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); }