Probleme d'iterateur pour boucle for

L'auteur de ce sujet a trouvé une solution à son problème.
Auteur du sujet

Bonjour,

j'ai deja poste mon probleme dans le fil de mon post sur mon projet mais j'ai peur que ca passe un peu inapercue et donc de ne pas avoir d'aide donc je reposte ici, au pire quand le probleme sera resolut je fermerai le sujet et un modo pourra le supprimer.

lien vers le fil d'actualite de mon projet

du coup voila il n'y qu'a suivre le lien pour tomber sur mon probleme :)

Je mets tout de meme une description rapide de ce qui m'arrive : lors de mon algo Astar, j'ai une fonction qui calcule les enfants du dernier noeud ajoute a la close list et les compare avec ce qui se trouve deja dans la close list et dans l'open list grace a 2 boucles for pour parcourir chacune des listes. Tout fonctionne parfaitement bien, j'arrive a eviter les explorations multiples jusqu'a l'ajout du 3e noeud dans la close list, au moment de calculer ses enfants et de les comparer avec les 2 listes, les iterateurs des 2 boucles for se mettent a commencer a 2, sans que je comprenne pourquoi, et reparte de 0 apres …

Voila pour mon probleme, merci d'avance pour votre aide.

Auteur du sujet

ok tres bien alors je vais developper mon probleme (au passage si tu as une idee d'ou peut venir l'erreur n'hesite pas ;) )

Je fais un Astar dans mon jeu de plateau au deplacement case par case pour permettre de mettre en surbrillance le chemin que le personnage va empreinter si le joueur clic avec la souris. J'ai les bases du truc mais en gros pour l'instant mon algo explore plusieurs fois les memes noeuds du coup j'ai rajoute quelques modifications afin de remedier a ce probleme. Voici la fonction :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
    //function conputing children of a node depending on the movements allowed from this node
    private void computeChildren(bool[] allowMovement)
    {
        bool check = true;
        for(int i = 0; i < allowMovement.Length; i++)
        {
            //if the movement is allowed
            if(allowMovement[i] == true)
            {
                //create a new node with all the child informations
                NodeClass nodeTemp2 = new NodeClass(new Vector3 (closeList.Last().getNodePosition().x + movement[i].x, closeList.Last().getNodePosition().y + movement[i].y, closeList.Last().getNodePosition().z + movement[i].z));
                nodeTemp2.setH(System.Convert.ToInt32 (Mathf.Abs (arrivingPosition.x - nodeTemp2.getNodePosition().x) + Mathf.Abs (arrivingPosition.z - nodeTemp2.getNodePosition().z)));
                nodeTemp2.setParent(closeList.Last().getNodePosition());
                nodeTemp2.setParentG(closeList.Last().getG());
                nodeTemp2.setG(nodeTemp2.getParentG() + 1 );
                nodeTemp2.setF(nodeTemp2.getG() + nodeTemp2.getH());
                check = true;
                for(int j = 0; j < closeList.Count; j++)
                {

                    if(closeList[j].getNodePosition() == nodeTemp2.getNodePosition())
                       check = false;
                    Debug.Log("<<<<<<<<<<<<<<<closeList element : " + closeList[j].getNodePosition() + "  " + nodeTemp2.getNodePosition() + "  " + check + j);
                }
                for(int k = 0; k < openList.Count; k++)
                {
                    if(openList[k].getNodePosition() == nodeTemp2.getNodePosition() && openList[k].getF() < nodeTemp2.getF())
                        check = false;
                    Debug.Log("<<<<<<<<<<<<<<<openList element : " + openList[k].getNodePosition() + openList[k].getF() +  "  " + nodeTemp2.getNodePosition() + nodeTemp2.getF() + "  " + check + k);
                }
                if(check == true)
                {
                    Debug.Log("-----------child and weight : " +  nodeTemp2.getNodePosition() + "  " + nodeTemp2.getF());
                    //and add it to the openlist
                    openList.Add(nodeTemp2);
                }
            }
        }
    }

Cette fonction est cense calculer les enfants du dernier noeud ajoute a la close list, verifier que l'enfant n'est pas dans la deja dans la close list ou dans l'open list avec un poids plus faible et si toutes ces conditions sont remplies alors elle ajoute l'enfant a l'open list.

Tout marche tres bien jusqu'au calcul des enfants du troisieme noeud ajoute a la close list, a ce moment ni l'iterateur j ni k ne demarrent a 0 mais a 2 …

logs

ce qui est bizarre c'est que ca ne fait ca que sur le 3e noeud ajoute a la close list, et seulement pour ses enfants 2 et 3 (on ne voit pas sur l'image mais pour le calcul de l'enfant suivant la 4eme direction les iterateurs repartent de 0).

Franchement j'avoue que je seche car c'est la premiere fois qu'un probleme pareil m'arrive … Si vous voyez des incoherences dans cette fonction … merci de me le dire :) en attendant je vais peut etre passer un peu a la modelisation 3D des personnages histoire de changer.

Au passage mon code est dispo sur mon github donc n'hesitez pas a telecharger l'integralite des scripts pour comprendre comment ca marche.

Édité par MeliMelo

Auteur du sujet

Bon et bien probleme resolu …

Je ne sais toujours pas exactement quel etait le probleme mais maintenant les logs marches comme il faut (peut-etre le fait que j'avais active l'option collapse dans la console .. Je ne suis pas sur du tout).

Je n'ai pratiquement rien modifie donc je doute que ca venait du code … Du coup j'ai quand meme apporte quelques ameliorations a cette fonction : deja la verification par rapport a l'openList se fait seulement si on a pas trouve l'element dans la closeList (si il est deja dans la closeList on sait deja qu'on explorera pas ce noeud donc pas la peine de verifier s'il est en plus dans l'openList) et je vais mettre un break dans les boucles for histoire de sortir direct si on trouve l'element dans une des 2 listes. Pas la peine d'explorer plus les listes, si on a deja trouve l'element dans le debut d'une des 2 listes de toutes facons on explorera pas ce noeud.

Voila par contre j'ai des doutes quand a la complexite de cette fonction, notamment car 2 boucle for l'une dans l'autre c'est assez sale je pense et parce que depuis que j'ai implemente ces verifications, le changement de material pour la case survole s'effectue avec un delai …

EDIT : Apres verification c'etait bien a cause de l'option collapse car en fait l'element apparaissait deja plus haut dans la console du coup le test sur les 2 premiers element de la liste etait regroupe.

Par contre apres verification aussi, c'est bien les 2 boucles for qui font totalement lagger mon programme … Je trouve ca bizarre parce que pour l'instant mon jeu ne comprends pas beaucoup de code et si il commence deja a lagger a cause d'un malheureux petit algo Astar je suis dans la mouise ! Du coup tous conseils pour ameliorer la complexite de cette fonction sont les bienvenues.

voici le nouveau code de la fonction :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
  //function conputing children of a node depending on the movements allowed from this node
  private void computeChildren(bool[] allowMovement)
  {
      bool check = true;
      for(int i = 0; i < allowMovement.Length; i++)
      {
          //if the movement is allowed
          if(allowMovement[i] == true)
          {
              //create a new node with all the child informations
              NodeClass nodeTemp2 = new NodeClass(new Vector3 (closeList.Last().getNodePosition().x + movement[i].x, closeList.Last().getNodePosition().y + movement[i].y, closeList.Last().getNodePosition().z + movement[i].z));
              nodeTemp2.setH(System.Convert.ToInt32 (Mathf.Abs (arrivingPosition.x - nodeTemp2.getNodePosition().x) + Mathf.Abs (arrivingPosition.z - nodeTemp2.getNodePosition().z)));
              nodeTemp2.setParent(closeList.Last().getNodePosition());
              nodeTemp2.setParentG(closeList.Last().getG());
              nodeTemp2.setG(nodeTemp2.getParentG() + 1 );
              nodeTemp2.setF(nodeTemp2.getG() + nodeTemp2.getH());
              check = true;
              for(int j = 0; j < closeList.Count; j++)
              {

                  if(closeList[j].getNodePosition() == nodeTemp2.getNodePosition())
                  {
                     check = false;
                      break;
                  }
                  Debug.Log("<<<<<<<<<<<<<<<closeList element : " + closeList[j].getNodePosition() + "  " + nodeTemp2.getNodePosition() + "  " + check + j);
              }
              if(check == true)
              {
                  for(int k = 0; k < openList.Count; k++)
                  {
                      if(openList[k].getNodePosition() == nodeTemp2.getNodePosition() && openList[k].getF() <= nodeTemp2.getF())
                      {
                          check = false;
                          break;
                      }
                      Debug.Log("<<<<<<<<<<<<<<<openList element : " + openList[k].getNodePosition() + openList[k].getF() +  "  " + nodeTemp2.getNodePosition() + nodeTemp2.getF() + "  " + check + k);
                  }
              }
              if(check == true)
              {
                  Debug.Log("-----------child and weight : " +  nodeTemp2.getNodePosition() + "  " + nodeTemp2.getF());
                  //and add it to the openlist
                  openList.Add(nodeTemp2);
              }
          }
      }
  }

Édité par MeliMelo

Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte