Évacuation d'une salle

Bonjour,

J'essaye de programmer, dans le cadre d'un projet en informatique, une fonction qui va donner le temps d'évacuation d'une salle remplie de personnes et d'obstacles (comme des tables par exemple) en nombre d'itérations. Elle prend en arguments un tableau (composé de 0 (les vides), de 1 (les personnes) et de 2 (les obstacles)) modélisant la salle et la position (iporte,jporte) de la porte. Pour chaque 1 je calcule la distance à la porte des 4 cases l'entourant grâce à la formule : distance = sqrt((i-iporte)²+(j-jporte)²). La case vide de distance minimale reçoit un 3 (pour que le 1 ne soit pas déplacé plusieurs fois en une boucle) et l'ancienne un 0. Une boucle rechange ensuite tous les 3 en 1. Si la case contient un obstacle (2) ou est vide (0), elle n'est pas modifiée. A chaque entrée de boucle en remet à 0 la porte. Lorsque la somme des cases du tableau est égale à la somme des obstacles (il n'y a plus aucun 1) la fonction s'arrête et renvoie le nombre d'itérations nécessaires à l'évacuation de la salle. J'ai essayé de coder cette fonction en Python mais elle ne s'arrête pas et je ne vois pas où est le problème. Voilà le code de la fonction, est-ce que vous pourriez m'aider à voir ce qui ne vas pas ? Merci d'avance !

Code:

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
import numpy as np
import numpy.random as rd
 
def evacuation (M,iporte,jporte):
    Temps_evacuation=0
    (L,l)=np.shape(M)
    nombre_obstacles=0
    for i in range (L):
        for j in range (l):
            if M[i,j]==2:
                nombre_obstacles+=1
    while np.sum(M)>2*nombre_obstacles:
        print M        
        Temps_evacuation+=1
        M[iporte,jporte]=0 #On remet la porte à 0
        for i in range (L):
            for j in range (l):
                if M[i,j]==1:
                    distance=np.ones(4)*1000 #On génère un vecteur rempli d'un grand nombre pour que le nombre reste grand si on ne peut pas calculer la distance
                    if i>=0 and i+1<=L and j>=0 and j+1<=l:
                        if i>0 and M[i-1,j]==0:
                            distance[0]=np.sqrt((i-1-iporte)**2+(j-jporte)**2) #case du haut
                        if i<L-1 and M[i+1,j]==0:
                            distance[1]=np.sqrt((i+1-iporte)**2+(j-jporte)**2) #case du bas
                        if j>0 and M[i,j-1]==0:
                            distance[2]=np.sqrt((i-iporte)**2+(j-1-jporte)**2) # case de gauche
                        if j<l-1 and M[i,j+1]==0:
                            distance[3]=np.sqrt((i-iporte)**2+(j+1-jporte)**2) # case de droite
                            distancemin = min (distance)
                            indice_case_valeur_min=[]
                            for k in range (4): #On cherche l'indice associé à la valeur minimale
                                if distance[k]==distancemin:
                                    indice_case_valeur_min.append(k)
                            if len (indice_case_valeur_min)==2: #Si deux distances sont les mêmes on tire au hasard
                                indice=rd.randint (0,2)
                                if indice==0:
                                    indice_case_valeur_min=indice_case_valeur_min[0]
                                if indice==1:
                                    indice_case_valeur_min=indice_case_valeur_min[1]
                            else :
                                indice_case_valeur_min=indice_case_valeur_min[0]
                            if indice_case_valeur_min==0 and i>0 and M[i-1,j]!=2:
                                M[i-1,j]=3 
                                M[i,j]=0
                            if indice_case_valeur_min==1 and i<L-1 and M[i+1,j]!=2:
                                M[i+1,j]=3
                                M[i,j]=0
                            if indice_case_valeur_min==2 and j>0 and M[i,j-1]!=2:
                                M[i,j-1]=3
                                M[i,j]=0
                            if indice_case_valeur_min==3 and j<l-1 and M[i,j+1]!=2:
                                M[i,j+1]=3
                                M[i,j]=0
                        if M[i,j]==2: #Les 2 sont inchangés
                            M[i,j]=2
                        if M[i,j]==0: #Les 0 sont inchangés
                            M[i,j]=0
        for i in range (L): #On rechange les 3 en 1
            for j in range (l):
                if M[i,j]==3:
                    M[i,j]=1
    return Temps_evacuation