Upload New File

programme_foule_float_avec_pilier__local_.py

+# -*- coding: utf-8 -*-
+"""
+Created on Fri May 20 16:38:09 2022
+
+@author: Arthur
+"""
+
+run_actif = 0
+import random as rand
+from math import *
+from tkinter import *
+from time import *
+from copy import *
+def fenetre (n,m,nombre_de_personnes,taille_personnes,taille_sortie) :
+    # n est la hauteur (distance verticale) et m la longueur (distance horizontale)
+    # taille_personnes est le DIAMÈTRE des cercles
+    global run_actif
+    global temps
+    global Foule_precedente
+    temps = 0
+    delta_t = 0.1
+    fen_princ = Tk()
+
+    fen_princ.title("ESSAI AVEC CANVAS")
+
+    fen_princ.geometry(str(n+200)+"x"+str(m))
+    
+    DISTANCE_PILIER = 110
+    RAYON_PILIER = 30
+    
+
+    monCanvas = Canvas(fen_princ, width=n, height=m, bg='white')
+    monCanvas.grid(row=0,column=0, padx=10,pady=10)
+    monCanvas.create_line(25,25,25,m-25, width=2, fill="black")
+    monCanvas.create_line(n-25,m-25,25,m-25, width=2, fill="black")
+    monCanvas.create_line(n-25,m-25,n-25,m//2+taille_sortie//2, width=2, fill="black")
+    monCanvas.create_line(n-25,25,n-25,m//2-taille_sortie//2, width=2, fill="black")
+    monCanvas.create_line(25,25,n-25,25, width=2, fill="black")
+    
+    porte = [n-25, m//2-taille_sortie//2, n-25, m//2+taille_sortie//2] # coordonnées de la porte
+    
+    sortie = [porte[0], m//2] # sortie sur l’axe horizontal
+    cible_bas = [n-25, min((porte[3] + sortie[1]) / 2, porte[3] - taille_personnes/2)]
+    cible_haut = [n-25, max((porte[1] + sortie[1]) / 2, porte[1] + taille_personnes/2)]
+    Foule=[]
+    Positions_possibles=[]
+    centre_pilier = [sortie[0]-DISTANCE_PILIER, sortie[1]]
+    coord_pilier = [centre_pilier[0]-RAYON_PILIER,centre_pilier[1]-RAYON_PILIER,]
+    avatar_pilier = monCanvas.create_oval(centre_pilier[0]-RAYON_PILIER,
+                                          centre_pilier[1]-RAYON_PILIER,
+                                          centre_pilier[0]+RAYON_PILIER,
+                                          centre_pilier[1]+RAYON_PILIER,
+                                          width=0,
+                                          fill = "red")
+    
+    cible_bas_pilier = [centre_pilier[0],
+                         centre_pilier[1] + RAYON_PILIER + taille_personnes/2]
+    cible_haut_pilier = [centre_pilier[0],
+                        centre_pilier[1] - (RAYON_PILIER + taille_personnes/2)]
+    
+    
+    def centre(coord):
+        return [coord[0]+(taille_personnes)/2,coord[1]+(taille_personnes)/2]
+    
+    def distance(coord1, coord2):
+        return sqrt((coord1[0]-coord2[0])**2+(coord1[1]-coord2[1])**2) 
+    
+    def produit_scalaire (u,v):
+        return u[0] * v[0] + u[1] * v[1]
+    
+    def norme(u):
+        return sqrt(produit_scalaire(u,u))
+    
+    def angle(u,v):
+        return acos(produit_scalaire(u,v) / (norme(u)*norme(v)))
+     
+        
+    def collision(coord1,coord2):
+        # renvoie un booléen : true si il y a collision ...
+        # ... entre les deux personnes représentées par les coordonées
+        
+        d = distance(coord1,coord2)
+        return d<=taille_personnes
+    
+    def collision_pilier(coord):
+        d = distance(centre(coord), centre_pilier)
+        return (d <= taille_personnes//2 + RAYON_PILIER)
+    
+    for i in range(25,n-24-taille_personnes,taille_personnes):
+        for j in range (25,m-24-taille_personnes,taille_personnes):
+            if not collision_pilier([i,j]):
+                Positions_possibles.append([i,j])
+            
+            
+            # on référence les positions possibles (cadrillage)
+            
+            
+    for k in range(nombre_de_personnes):
+        
+        l=rand.randint(0,len(Positions_possibles)-1)
+        
+        [i,j]=Positions_possibles[l]
+        avatar=monCanvas.create_oval(i,j,i+taille_personnes,j+taille_personnes, width=0, fill="blue")
+        # avatar est le cercle
+        Foule.append([avatar,0,0,i,j])
+        #les quatre nombres associés à l'avatar representent sa vitesse et sa position
+        
+        Positions_possibles = Positions_possibles[:l] + Positions_possibles[l+1:]
+    
+    Foule_precedente = deepcopy(Foule)
+    
+    print(Foule)
+    
+    def centre(coord):
+        return [coord[0]+(taille_personnes)/2,coord[1]+(taille_personnes)/2]
+    
+    def distance(coord1, coord2):
+        return sqrt((coord1[0]-coord2[0])**2+(coord1[1]-coord2[1])**2)
+    
+
+        
+     
+        
+    def collision(coord1,coord2):
+        # renvoie un booléen : true si il y a collision ...
+        # ... entre les deux personnes représentées par les coordonées
+        
+        d = distance(coord1,coord2)
+        return (d<=(taille_personnes))
+    
+    
+        
+        """
+    def deplacement_orthogonal(coord1,coord2):
+        # renvoie la direction du vecteur vitesse du cercle 1 ...
+        # ... lors d'un déplacement orthogonalement à la droite (O1O2)
+        
+        centre1 = centre(coord1)
+        centre2 = centre(coord2)
+        
+        d = distance(coord1, coord2)
+        
+        u=[(centre2[0]-centre1[0])/d,(centre2[1]-centre1[1])/d]
+        # u est le vecteur unitaire qui appartient à la droite reliant centre1 et centre2 dirigée vers 2
+        
+        if u[1]>=0: # on veut que le dx du vecteur ortho soit positif
+            return [5*u[1],-5*u[0]]
+        
+        else:
+            return [-5*u[1],5*u[0]]
+
+        """
+        
+    def deplacement_orthogonal_centres (centre1, centre2, v):
+        d=((sqrt((centre1[0]-centre2[0])**2+(centre1[1]-centre2[1])**2)))
+        u=[(centre2[0]-centre1[0])/d,(centre2[1]-centre1[1])/d]
+        #vecteur unitaire qui  appartient à la droite reliant centre1 et centre2 dirigé vers 2
+        
+        # on sépare le cas où la distance selon x est plus ou moins grande
+        # que la distance selon y
+        distance_x = sortie[0] - centre1[0]
+        distance_y = abs(sortie[1] - centre1[1])
+        if distance_y > distance_x :
+            if centre1[1]<=sortie[1] :
+                if u[0]>=0:
+                    return [-v*u[1],v*u[0]]
+                else:
+                    return [v*u[1],-v*u[0]]
+            else:
+                if u[0]>=0:
+                    return [v*u[1],-v*u[0]]
+                else:
+                    return [-v*u[1],v*u[0]]
+        else:
+            if u[1]>=0: # on veut que le dx du vecteur ortho soit positif
+                return [v*u[1],-v*u[0]]
+            
+            else:
+                return [-v*u[1],v*u[0]]
+    
+    def deplacement_orthogonal(coord1,coord2,v):
+        
+        #déplacement de contournement à la vitesse v
+        
+        centre1 = centre(coord1)
+        centre2 = centre(coord2)
+        return deplacement_orthogonal_centres(centre1, centre2, v)
+        
+        """
+        d=((sqrt((centre1[0]-centre2[0])**2+(centre1[1]-centre2[1])**2)))
+        u=[(centre2[0]-centre1[0])/d,(centre2[1]-centre1[1])/d]
+        #vecteur unitaire qui  appartient à la droite reliant centre1 et centre2 dirigé vers 2
+        
+        # on sépare le cas où la distance selon x est plus ou moins grande
+        # que la distance selon y
+        distance_x = sortie[0] - centre1[0]
+        distance_y = abs(sortie[1] - centre1[1])
+        if distance_y > distance_x :
+            if coord1[1]<=sortie[1] :
+                if u[0]>=0:
+                    return [-v*u[1],v*u[0]]
+                else:
+                    return [v*u[1],-v*u[0]]
+            else:
+                if u[0]>=0:
+                    return [v*u[1],-v*u[0]]
+                else:
+                    return [-v*u[1],v*u[0]]
+        else:
+            if u[1]>=0: # on veut que le dx du vecteur ortho soit positif
+                return [v*u[1],-v*u[0]]
+            
+            else:
+                return [-v*u[1],v*u[0]]
+            """
+
+    """def deplacement_orthogonal_bis(coord1,coord2):
+        
+        centre1 = centre(coord1)
+        centre2 = centre(coord2)
+        
+        d = distance(coord1, coord2)
+        
+        u=[(centre2[0]-centre1[0])/d,(centre2[1]-centre1[1])/d] 
+        #vecteur unitaire qui appartient à la droite reliant centre1 et centre2 dirigée vers 2
+        
+        if u[1]>=0:
+            return [2*u[1],-2*u[0]]
+        else:
+            return [-2*u[1],2*u[0]]"""
+        
+    
+    """def deplacement_simple(): 
+        # déplacement en l’absence de collision (inutile ?)
+        
+        dx=((porte[0] - monCanvas.coords(p1)[0]) / (sqrt(((porte[0]-monCanvas.coords(p1)[0])**2)+((porte[4]-monCanvas.coords(p1)[1])**2))))*5
+        dy=((porte[4]-monCanvas.coords(p1)[1])/(sqrt(((porte[0]-monCanvas.coords(p1)[0])**2)+((porte[4]-monCanvas.coords(p1)[1])**2))))*5
+        dx=int(dx)
+        dy=int(dy)
+        monCanvas.move(p1,dx,dy)
+        fen_princ.after(30,deplacement_simple)"""
+        
+    def listes_egales (L,M):
+        # renvoie True si L et M sont identiques
+        
+        b = True
+        if len(L) == len (M):
+            for i in range (len(L)):
+                b = (b and(L[i]==M[i]))
+            return b
+        else :
+            return False
+        
+        
+    def collision_murs(p, nouvelle_coord, v):
+        if (nouvelle_coord[0]+taille_personnes ) >= (n-25) and ((nouvelle_coord[1]+taille_personnes) >= m//2+taille_sortie//2 or (nouvelle_coord[1])<= m//2-taille_sortie//2): #si p rentre dans un mur
+            nouvelle_coord[0] = (n-25-taille_personnes)
+            #p se colle au mur
+            p[1]= nouvelle_coord[0]- p[3]
+            if p[4]<sortie[1]:
+                p[2]= v
+                #p se déplace vers la sortie
+            else:
+                p[2] = -v
+            nouvelle_coord[1]=p[4]+p[2]
+        if (nouvelle_coord[1] + taille_personnes) >= (m-25):
+            nouvelle_coord[1] = (m-25-taille_personnes)
+            #p se colle en haut de la salle
+            p[2]= nouvelle_coord[1]- p[4]
+            p[1]=v
+            nouvelle_coord[0]=p[1] +p[3]
+        if (nouvelle_coord[1] - taille_personnes) <= 25:
+            nouvelle_coord[1] = (25+taille_personnes)
+            #p se colle en bas de la salle
+            p[2]= nouvelle_coord[1]- p[4]
+            p[1]=v
+            nouvelle_coord[0]=p[1] +p[3]
+            
+        return nouvelle_coord
+    
+        
+    def test_collisions (i, col, p, v, nouvelle_coord):
+        for j in range (nombre_de_personnes) :
+        #on parcourt la Foule pour tester les collisions
+            if i != j and Foule[j] != "sorti":
+                if (collision(Foule[j][3:5],nouvelle_coord)):
+                    col = col +1
+                    if col==1:
+                        direction=deplacement_orthogonal(p[3:5],Foule[j][3:5],v)
+                        p[1]=direction[0]
+                        #on change la direction de p de manière à lui faire contourner l'obstacle
+                        p[2]=direction[1]
+                        nouvelle_coord= [p[3]+p[1],p[4]+p[2]]
+                        
+                        """
+                        # contact avec le mur de la sortie
+                        if (nouvelle_coord[0]+taille_personnes ) >= (n-25) and ((nouvelle_coord[1]+taille_personnes) >= m//2+taille_sortie//2 or (nouvelle_coord[1])<= m//2-taille_sortie//2):                                        #si p rentre dans un mur
+                            nouvelle_coord[0] = (n-25-taille_personnes)
+                            #p se colle au mur
+                            p[1]= nouvelle_coord[0]- p[3]
+                            if p[4]<sortie[1]:
+                                p[2]= v
+                                #p se déplace vers la sortie
+                            else:
+                                p[2] = -v
+                            nouvelle_coord[1]=p[4]+p[2]
+                            
+                        # contact avec le mur du haut
+                        if (nouvelle_coord[1] + taille_personnes) >= (m-25):
+                            nouvelle_coord[1] = (m-25-taille_personnes)
+                            #p se colle en haut de la salle
+                            p[2]= nouvelle_coord[1]- p[4]
+                            p[1]=v
+                            nouvelle_coord[0]=p[1] +p[3]
+                            
+                        # contact avec le mur du bas
+                        if (nouvelle_coord[1] - taille_personnes) <= 25:
+                            nouvelle_coord[1] = (25+taille_personnes)
+                            #p se colle en bas de la salle
+                            p[2]= nouvelle_coord[1]- p[4]
+                            p[1]=v
+                            nouvelle_coord[0]=p[1] +p[3]
+                        """
+                        
+                        nouvelle_coord = collision_murs(p, nouvelle_coord, v)
+                            
+        
+        if (collision_pilier(nouvelle_coord)):
+            col = col +1
+            if col==1:
+                direction=deplacement_orthogonal(centre(p[3:5]),centre_pilier,v)
+                p[1]=direction[0]
+                #on change la direction de p de manière à lui faire contourner l'obstacle
+                p[2]=direction[1]
+                nouvelle_coord= [p[3]+p[1],p[4]+p[2]]
+                
+                """
+                # contact avec le mur de la sortie
+                if (nouvelle_coord[0]+taille_personnes ) >= (n-25) and ((nouvelle_coord[1]+taille_personnes) >= m//2+taille_sortie//2 or (nouvelle_coord[1])<= m//2-taille_sortie//2):                                        #si p rentre dans un mur
+                    nouvelle_coord[0] = (n-25-taille_personnes)
+                    #p se colle au mur
+                    p[1]= nouvelle_coord[0]- p[3]
+                    if p[4]<sortie[1]:
+                        p[2]= v
+                        #p se déplace vers la sortie
+                    else:
+                        p[2] = -v
+                    nouvelle_coord[1]=p[4]+p[2]
+                    
+                # contact avec le mur du haut
+                if (nouvelle_coord[1] + taille_personnes) >= (m-25):
+                    nouvelle_coord[1] = (m-25-taille_personnes)
+                    #p se colle en haut de la salle
+                    p[2]= nouvelle_coord[1]- p[4]
+                    p[1]=v
+                    nouvelle_coord[0]=p[1] +p[3]
+                    
+                # contact avec le mur du bas
+                if (nouvelle_coord[1] - taille_personnes) <= 25:
+                    nouvelle_coord[1] = (25+taille_personnes)
+                    #p se colle en bas de la salle
+                    p[2]= nouvelle_coord[1]- p[4]
+                    p[1]=v
+                    nouvelle_coord[0]=p[1] +p[3]
+                """
+                
+                nouvelle_coord = collision_murs(p, nouvelle_coord, v)
+                
+        return(col,p,nouvelle_coord)
+        
+        
+    def vecteur_direction (coord_personne, coord_cible, v):
+        # renvoie le vecteur direction vers la cible, de norme v
+        
+        centre_personne = centre(coord_personne)
+        d = distance(centre_personne, coord_cible)
+        return [(coord_cible[0] - centre_personne[0]) * (v/d),
+                (coord_cible[1] - centre_personne[1]) * (v/d)]
+    
+    def rotation (v, alpha):
+        [x,y] = v
+        return [cos(alpha) * x - sin(alpha) * y,
+                sin(alpha) * x + cos(alpha) * y]
+    
+    
+    def ciblage(p, v):
+        dx,dy=0,0
+        if p[4]<=(porte[1]) :
+            # au-dessus de la porte
+            [dx, dy] = vecteur_direction(p[3:5], cible_haut, v)
+            
+            angle_min = asin(min( (RAYON_PILIER + taille_personnes/2)/distance(centre(p[3:5]), centre_pilier), 1))
+            # angle minimal pour éviter le pilier
+            
+            alpha = angle([dx,dy], vecteur_direction(p[3:5], centre_pilier, v))
+            if angle_min > alpha and centre(p[3:5])[0] < centre_pilier[0] : # s’il y a collision de la trajectoire avec le pilier
+                [dx, dy] = rotation(vecteur_direction(p[3:5],centre_pilier,v), -angle_min)
+            
+        elif  p[4]+taille_personnes>=(porte[3]):
+            # en-dessous de la porte
+            [dx, dy] = vecteur_direction(p[3:5], cible_bas, v)
+            
+            angle_min = asin(min( (RAYON_PILIER + taille_personnes/2)/distance(centre(p[3:5]), centre_pilier), 1))
+            # angle minimal pour éviter le pilier
+            
+            alpha = angle([dx,dy], vecteur_direction(p[3:5], centre_pilier, v))
+            # angle de la vitesse par rapport à l’axe p - pilier
+            if angle_min > alpha and centre(p[3:5])[0] < centre_pilier[0] : # s’il y a collision de la trajectoire avec le pilier
+                [dx, dy] = rotation(vecteur_direction(p[3:5],centre_pilier,v), angle_min)
+            
+        else:
+            centre_p = centre(p[3:5])
+            if abs(centre_p[1] - sortie[1]) <= RAYON_PILIER + taille_personnes/2 \
+                and centre_p[0] < centre_pilier[0]:
+                # trajectoire qui croise le pilier --> on vise donc une cible_pilier
+                if centre_p[1] <= sortie[1]:
+                    [dx, dy] = vecteur_direction(p[3:5], cible_haut_pilier, v)
+                else:
+                    [dx, dy] = vecteur_direction(p[3:5], cible_bas_pilier, v)
+            else:
+                dy=0
+                dx=v
+        return[dx,dy]
+    
+    def round_down(x, p):
+        y = floor(x * 10**p)
+        return round(y / 10**p, p)
+    
+    def quit () :
+        fen_princ.destroy()
+    
+    # BOUCLE
+       
+    def run () :
+        global run_actif
+        global temps
+        global Foule_precedente
+        
+        if run_actif == 0:
+            run_actif = 1
+            for i in range (nombre_de_personnes) :
+                p=Foule[i] 
+                # p contient l'entité, son vecteur vitesse et sa position
+                # p = [avatar, dx, dy, x, y]
+                
+                
+                
+                if p!="sorti" and (porte[0]-p[3])>(taille_personnes)/2 :
+                    """
+                    if p[4]+taille_personnes/2<=(porte[1]) :
+                        # au-dessus de la porte
+                        [dx, dy] = vecteur_direction(p[3:5], cible_haut, 5)
+                        
+                    elif  p[4]-taille_personnes/2>=(porte[3]):
+                        # en-dessous de la porte
+                        [dx, dy] = vecteur_direction(p[3:5], cible_bas, 5)
+                        
+                    else:
+                        centre_p = centre(p[3:5])
+                        if abs(centre_p[1] - sortie[1]) <= RAYON_PILIER + taille_personnes/2 \
+                            and centre_p[0] < centre_pilier[0]:
+                            # trajectoire qui croise le pilier --> on vise donc une cible_pilier
+                            if centre_p[1] <= sortie[1]:
+                                [dx, dy] = vecteur_direction(p[3:5], cible_haut_pilier, 5)
+                            else:
+                                [dx, dy] = vecteur_direction(p[3:5], cible_bas_pilier, 5)
+                        else:
+                            dy=0
+                            dx=5
+                        #la norme du vecteur vitesse est de 5
+                    """
+                    
+                    [dx,dy] = ciblage(p, 5)
+                    
+                    p[1]=dx
+                    p[2]=dy
+                    nouvelle_coord= [p[3]+dx,p[4]+dy]
+                    #coordonées futur de p si il n'y a pas de collision
+                    
+                    """
+                    if (nouvelle_coord[0]+taille_personnes ) >= (n-25) and ((nouvelle_coord[1]+taille_personnes) >= m//2+taille_sortie//2 or (nouvelle_coord[1])<= m//2-taille_sortie//2):
+                        #si p rentre dans un mur
+                        nouvelle_coord[0] = (n-25-taille_personnes)
+                        #p se colle au mur
+                        p[1]= nouvelle_coord[0]- p[3]
+                        if p[4]<sortie[1]:
+                            p[2]= 5
+                            #p se déplace vers la sortie
+                        else:
+                            p[2] = -5
+                        nouvelle_coord[1]=p[4]+p[2]
+                        #on rentre les coordonées modifiées de p
+                    """
+                    nouvelle_coord = collision_murs(p, nouvelle_coord, 5)
+                    col=0
+                    #nombre de collisions
+                    
+                    """
+                    for j in range (len(Foule)):
+                    #on parcourt la Foule pour tester les collisions
+                        if i != j and Foule[j] != "sorti":
+                            if (collision(Foule[j][3:5],nouvelle_coord)):
+                                col = col +1
+                                if col==1:
+                                    direction=deplacement_orthogonal(p[3:5],Foule[j][3:5],5)
+                                    p[1]=direction[0]
+                                    #on change la direction de p de manière à lui faire contourner l'obstacle
+                                    p[2]=direction[1]
+                                    nouvelle_coord= [p[3]+p[1],p[4]+p[2]]
+                                    if (nouvelle_coord[0]+taille_personnes ) >= (n-25) and ((nouvelle_coord[1]+taille_personnes) >= m//2+taille_sortie//2 or (nouvelle_coord[1])<= m//2-taille_sortie//2):                                        #si p rentre dans un mur
+                                        nouvelle_coord[0] = (n-25-taille_personnes)
+                                        #p se colle au mur
+                                        p[1]= nouvelle_coord[0]- p[3]
+                                        if p[4]<sortie[1]:
+                                            p[2]= 5
+                                            #p se déplace vers la sortie
+                                        else:
+                                            p[2] = -5
+                                        nouvelle_coord[1]=p[4]+p[2]
+                                    if (nouvelle_coord[1] + taille_personnes) >= (m-25):
+                                        nouvelle_coord[1] = (m-25-taille_personnes)
+                                        #p se colle en haut de la salle
+                                        p[2]= nouvelle_coord[1]- p[4]
+                                        p[1]=5
+                                        nouvelle_coord[0]=p[1] +p[3]
+                                    if (nouvelle_coord[1] - taille_personnes) <= 25:
+                                        nouvelle_coord[1] = (25+taille_personnes)
+                                        #p se colle en bas de la salle
+                                        p[2]= nouvelle_coord[1]- p[4]
+                                        p[1]=5
+                                        nouvelle_coord[0]=p[1] +p[3]
+                                        """
+                    
+                    (col,p,nouvelle_coord) = test_collisions(i, col, p, 5, nouvelle_coord)
+                    
+                    b=True
+                    for j in range (nombre_de_personnes):
+                        
+                        if i != j and Foule[j] != "sorti":
+                            b= b and not(collision(Foule[j][3:5],nouvelle_coord))
+                    
+                    b = b and not (collision_pilier(nouvelle_coord))
+                    
+                    if b :
+                        p[3:5]=nouvelle_coord
+                        monCanvas.move(p[0],round(p[1]),round(p[2]))
+                    
+                    else :
+                        """
+                        dx=((sortie[0]-p[3])/(sqrt(((sortie[0]-p[3])**2)+((sortie[1]-p[4])**2))))*2
+                         #vitesse en x
+                        
+                        if p[4]<=(porte[1]) :
+                             dy=(((porte[1]+sortie[1])/2-p[4])/(sqrt(((sortie[0]-p[3])**2)+((sortie[1]-p[4])**2))))*2
+                             #vitesse en y
+                        
+                        elif  p[4]>=(porte[3]):
+                             dy=(((porte[3]+sortie[1])/2-p[4])/(sqrt(((sortie[0]-p[3])**2)+((sortie[1]-p[4])**2))))*2
+                        
+                        else:
+                            centre_p = centre(p[3:5])
+                            if abs(centre_p[1] - sortie[1]) <= RAYON_PILIER + taille_personnes/2 \
+                                and centre_p[0] < centre_pilier[0]:
+                                # trajectoire qui croise le pilier --> on vise donc une cible_pilier
+                                if centre_p[1] <= sortie[1]:
+                                    [dx, dy] = vecteur_direction(p[3:5], cible_haut_pilier, 2)
+                                else:
+                                    [dx, dy] = vecteur_direction(p[3:5], cible_bas_pilier, 2)
+                            else:
+                                dy=0
+                                dx=2
+                            #la norme du vecteur vitesse est de 2
+                        """
+                        
+                        [dx,dy] = ciblage(p, 2)
+                        
+                        p[1]=dx
+                        p[2]=dy
+                        #vitesse en pixel(unité)
+                        
+                        nouvelle_coord= [p[3]+dx,p[4]+dy]
+                    #coordonées futur de p si il n'y a pas de collision
+                    
+                    """
+                    if (nouvelle_coord[0]+taille_personnes ) >= (n-25) and ((nouvelle_coord[1]+taille_personnes) >= m//2+taille_sortie//2 or (nouvelle_coord[1])<= m//2-taille_sortie//2):
+                        nouvelle_coord[0] = (n-25-taille_personnes)
+                        #p se colle au mur
+                        p[1]= nouvelle_coord[0]- p[3]
+                        if p[4]<sortie[1] :
+                            p[2]= 2
+                            #p se déplace vers la sortie
+                        else:
+                            p[2] = -2
+                        nouvelle_coord[1]=p[4]+p[2]
+                        #on rentre les coordonées modifiées de p
+                    """
+                    
+                    nouvelle_coord = collision_murs(p, nouvelle_coord, 2)
+                    col=0
+                    #nombre de collisions
+                    """
+                    for j in range (len(Foule)):
+                    #on parcourt la Foule pour tester les collisions
+                    
+                        if i != j and Foule[j] != "sorti":
+                            if (collision(Foule[j][3:5],nouvelle_coord)):
+                                col = col +1
+                                if col==1:
+                                    direction=deplacement_orthogonal(p[3:5],Foule[j][3:5],2)
+                                    p[1]=direction[0]
+                                    #on change la direction de p de manière à lui faire contourner l'obstacle
+                                    p[2]=direction[1]
+                                    nouvelle_coord= [p[3]+p[1],p[4]+p[2]]
+                                    if (nouvelle_coord[0]+taille_personnes ) >= (n-25) and ((nouvelle_coord[1]+taille_personnes) >= m//2+taille_sortie//2 or (nouvelle_coord[1])<= m//2-taille_sortie//2): #si p rentre dans un mur
+                                        nouvelle_coord[0] = (n-25-taille_personnes)
+                                        #p se colle au mur
+                                        p[1]= nouvelle_coord[0]- p[3]
+                                        if p[4]<sortie[1]:
+                                            p[2]= 2
+                                            #p se déplace vers la sortie
+                                        else:
+                                            p[2] = -2
+                                        nouvelle_coord[1]=p[4]+p[2]
+                                    if (nouvelle_coord[1] + taille_personnes) >= (m-25):
+                                        nouvelle_coord[1] = (m-25-taille_personnes)
+                                        #p se colle en haut de la salle
+                                        p[2]= nouvelle_coord[1]- p[4]
+                                        p[1]=2
+                                        nouvelle_coord[0]=p[1] +p[3]
+                                    if (nouvelle_coord[1] - taille_personnes) <= 25:
+                                        nouvelle_coord[1] = (25+taille_personnes)
+                                        #p se colle en bas de la salle
+                                        p[2]= nouvelle_coord[1]- p[4]
+                                        p[1]=2
+                                        nouvelle_coord[0]=p[1] +p[3]
+                        """
+                    (col,p,nouvelle_coord) = test_collisions(i, col, p, 2, nouvelle_coord)
+                    
+                    b=True
+                    for j in range (nombre_de_personnes):
+                        
+                        if i != j and Foule[j] != "sorti":
+                            b= b and not(collision(Foule[j][3:5],nouvelle_coord))
+                    b = b and not (collision_pilier(nouvelle_coord))
+                    
+                    if b :
+                        p[3:5]=nouvelle_coord
+                        monCanvas.move(p[0],int(p[3])-monCanvas.coords(p[0])[0],int(p[4])-monCanvas.coords(p[0])[1])
+                        
+                else :
+                    monCanvas.itemconfig(p[0], state=HIDDEN)
+                    Foule[i] = "sorti"
+                
+            if Foule == Foule_precedente:
+                temps = nan
+                quit()
+            if temps > 100000:
+                temps = nan
+                quit()
+            Foule_precedente = deepcopy(Foule)
+            
+            temps += 1
+            run_actif = 0
+            a=(len(Foule))*["sorti"]
+            if listes_egales(a, Foule):
+                quit()
+            fen_princ.after(100,run)
+            
+     
+        
+    zone2 = Frame(fen_princ, bg='#777777')
+    
+    zone2.grid(row=0,column=1,ipadx=5)
+
+    bouVert = Button(zone2, text="RUN", fg="white", bg="green", command = run)
+
+    bouRouge = Button(zone2, text="QUIT", fg="white", bg="red", command = quit)
+
+    bouVert.pack(side=LEFT, fill=Y, ipady=30, padx=10,pady=10)
+
+    bouRouge.pack(side=LEFT, fill=Y, ipady=30, padx=10,pady=10)
+    
+    fen_princ.mainloop()
+    
+    return temps * delta_t
+
+
+    
+fenetre(1000,600,100,30,100) 
\ No newline at end of file