diff --git a/programme_foule_float_avec_pilier__local_.py b/programme_foule_float_avec_pilier__local_.py
new file mode 100644
index 0000000000000000000000000000000000000000..04d9ea96903393af33136d49a4760a61a87f83ed
--- /dev/null
+++ b/programme_foule_float_avec_pilier__local_.py
@@ -0,0 +1,689 @@
+# -*- 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