Bonjour à tous !

Je suis actuellement en train d'adapter l'algorithme A* dans Blender afin de pouvoir tracer des câbles entre deux points de références. Je rencontre cependant un problème des plus étrange : certaines de mes variables influent les unes sur les autres alors qu'elles ne le devraient pas. Voici un petit exemple pour comprendre le problème :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
a=0
b=0
b=b+1
print (a)
>>0
print (b)
>>1
Ca c'est ce que j'obtiens, le résultat est tout à fait normal. Or dans mon cas spécifique, c'est comme si j'obtenais quelque chose comme ça :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
a=0
b=0
b=b+1
print (a)
>>1
print (b)
>>1
Comme si changer la valeur de "b" influe également sur celle de "a", ce qui me parait totalement illogique. J'espère que ce petit exemple est parlant. Voici donc la partie de mon code qui me pose ce problème spécifique.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
 
n=0    
for each in cable :
    startNode = cable[n][0].location
    endNode= cable[n][1].location
    currentNode = startNode
 
    if (currentNode != endNode):
        newPositionList = [(0,1), (0,-1), (1,0), (-1,0), (1,1), (1,-1), (-1,-1), (-1,1)]
        costList = []
        distanceArriveeList = []
        distanceDepartList = []
        cpt = 0
        for each in newPositionList :
 
            print (cpt)
            newNode= currentNode
 
            newNode[0] = newNode[0] + newPositionList[cpt][0]
            newNode[1] = newNode[1] + newPositionList[cpt][1]
            print(newNode)
            print ('currentNodeAfter=', currentNode)
            print ('startNode=', startNode)
 
            distanceDepart = math.sqrt((startNode[0]-newNode[0])**2 + (startNode[1]-newNode[1])**2)
            distanceDepartList.append (distanceDepart)
 
            distanceArrivee = math.sqrt((endNode[0]-newNode[0])**2 + (endNode[1]-newNode[1])**2)
            distanceArriveeList.append (distanceArrivee)
 
            cost = distanceDepart + distanceArrivee
            costList.append(cost)
 
            cpt=cpt+1
n=n+1
Dans ce cas, j'ai newNode qui prend la valeur de currentNode, qui prend lui même la valeur de startNode à l'initialisation de la boucle du pathfinding ( if (currentNode != endNode). Or il se trouve qu'après les lignes 19 et 20, newNode a changé la valeur de currentNode, qui a lui même changé la valeur de startNode, alors que les relations entre ces variables se font dans l'autre sens...
Ca fausse évidemment totalement la boucle, puisque newNode n'est pas réinitialisé à chaque passage dans (for each in newPositionList).

Bref, je suis totalement désappointé (c'est assez illogique de mon point de vue puisque c'est censé fonctionner dans l'autre sens) et j'ignore parfaitement d'où le problème peut venir. Si vous avez besoin du code dans son intégralité pour mieux saisir le problème, n'hésitez pas.

Je vous remercie d'avance, et vous souhaite de bonnes fêtes
Cdlt, Léo