Collisions en cascades : plus d'une centaine de boules s'entrechoquent !


Télécharger le projet
Commenter

Description

L'étude porte sur les collisions multiples entre un grand nombre d'objets (plus d'une centaine).
Il s'agit d'un sujet important pour les concepteurs de logiciels de jeu.
Elle montre l'intérêt d'utiliser les concepts de LISTE et de BIBLIOTHEQUE pour réduire le nombre de lignes de code.
(le script est commenté de façon détaillée pour les débutants en Python)

Source / Exemple : 


#! /usr/bin/env python 
# -*- coding: Latin-1 -*- 
# Python version 2.4.2 
# Tk version 8.4 
# IDLE version 1.1.2 
  
# <<< Collisions en cascades >>> 
  
############# PRESENTATION ################# 
  
# Ce script étudie la gestion des COLLISIONS entre plusieurs boules. 
# Le nombre (M) de boules est variable. 
# Commencer par choisir le nombre de boules: 1<M<100 
# (le programme fonctionne au-delà de 100, mais les boules deviennent très petites...), 
# Appuyer ensuite sur le bouton "Mettre les boules en place !", puis sur "Tirer !" 
# et enfin sur "Stop !", pour arrêter le mouvement, 
# Ainsi de suite. 
# Plus d'une centaine de boules peuvent être mises simultanément en mouvement 
# et s'entrechoquer.
# Un freinage ralentit les boules jusq'à leur immobilisation. 
  
############# COMMENTAIRE ################# 
  
# L'utilisation de LISTES (pour les coordonnées et la couleur des boules) et d'une BIBLIOTHEQUE 
# pour leur identification, permet de réduire considérablement le nombre de lignes de code. 
# C'est l'intérêt de ce script. 
# L'algorithme de collision est celui que j'avais présenté dans le code intitulé: 
# "BILLARD Français", avec une amélioration pour contrer les phénomènes "d'adhérence". 
  
  
from Tkinter import* 
from math import hypot,sqrt,floor 
from random import randrange 
from time import time 

def tirage(): 
    "mise en place d'un nombre variable de boules de couleurs différentes" 
    global flag,T,C,CS,M,d,x,y,dx,dy,F,ZERO,B,Cb
    flag=1 
    Bouton_tirage.config(state=DISABLED)
    Bouton_tirer.config(state=ACTIVE)
    can.delete(ALL)
    T=time() # mémorisation de la valeur du temps au démarrage 
    M=int(MM.get()) # entrée du nombre de boules choisi 
    if M<10:d=L/10 # limitation à L/10 du diamètre des boules pour M<10 
    else:d=L/(M+1) # le diamètre diminue en fonction du nombre de boules 
    
    # création de six LISTES: 
        # x: liste des abscisses du coin supérieur gauche des boules 
        # y: liste des ordonnées du coin supérieur gauche des boules 
        # dx: liste des vitesses horizontales des boules 
        # dy: liste des vitesses verticales des boules 
        # F: liste de 10 couleurs différentes 
        # ZERO: liste de valeurs "zéro"

    x,y,dx,dy=[L-d],[0],[-6],[-2] # initialisation (valeur du premier terme) de ces quatre listes 
    F=["orange","blue","red","green","brown","pink","grey","yellow","white","dark grey"] 
    ZERO=[0]  
    # extension aux termes de rangs suivants par la méthode "append" (qui allonge la liste,après le dernier terme): 
    # (les distributions en x,dx,dy sont aléatoires; celle en y est régulièrement répartie sur toute la hauteur du jeu) 
    # pour éviter que des boules soient mise en place dans le cercle blanc, on procède à deux extensions successives (de part et d'autre en abscisse)
    for i in range(0,int(floor(M/2))):x.append(randrange(0,L/2-D/2-d));y.append(H/M*(i+1));dx.append(randrange(-4,4));dy.append(randrange(-4,4));F.append(F[i]);ZERO.append(0) 
    for i in range(int(floor(M/2)),M-1):x.append(randrange(L/2+D/2-d,L-d));y.append(H/M*(i+1));dx.append(randrange(-4,4));dy.append(randrange(-4,4));F.append(F[i]);ZERO.append(0) 
          
    # création d'une bibliothèque des boules: 
    B={} 
    # mise en place des boules: 
    for i in range(0,M):B[i+1]=can.create_oval(x[i],y[i],x[i]+d,y[i]+d,fill=F[i]) 
    Cb=can.create_oval(L/2-D/2,H/2-D/2,L/2+D/2,H/2+D/2,outline="white") # cercle blanc au centre du jeu 
    C=0;can.C.config(text='%s'%C) # mise à zéro du compteur de collisions 
    CS=0;can.CS.config(text='%s'%CS) # mise à zéro du compteur de collisions par secondes

def tirer(): 
    "mise en mouvement de l'ensemble des boules et gestion des collisions" 
    global x,y,dx,dy,CC,C,CS,d,ZERO
    if flag==1 :
        Bouton_tirer.config(state=DISABLED)
        # mise en mouvement de la boule Bi, avec maintien dans les limites du jeu: 
        for i in range(0,M): 
            x[i],y[i]=x[i]+dx[i],y[i]+dy[i] # mise en mouvement de la boule Bi 
            dx[i],dy[i]=f*dx[i],f*dy[i] # freinage (f) 

            if dx==ZERO and dy==ZERO:stop() # arrêt lorsque toutes les vitesses sont nulles
            if hypot(dx[i],dy[i])<s: dx[i],dy[i]=0,0 # immobilisation lorsque la vitesse devient inférieure au seuil (s) 
            if x[i]>L-d:x[i],dx[i]=L-d,-dx[i] # rebond sur la bande droite 
            if x[i]<0:x[i],dx[i]=0,-dx[i] # rebond sur la bande gauche 
            if y[i]>H-d:y[i],dy[i]=H-d,-dy[i] # rebond sur la bande inférieure 
            if y[i]<0:y[i],dy[i]=0,-dy[i] # rebond sur la bande supérieure 

            # gestion de la COLLISION entre Bi et le cercle blanc (Cb): 
            X,Y=x[i]+d/2-L/2,y[i]+d/2-H/2 
            Z=hypot(X,Y) # distance entre les centres 
            if Z<=d/2+D/2:# si cette distance est inférieure à la somme des rayons                  
                CC+=1 # il y a collision (incrémentation du compteur CC)

                # algorithme de recul de Bi, sur sa direction initiale, pour revenir au stricte contact Bi/Cb:
                dX,dY=dx[i],dy[i]
                dZ=hypot(dX,dY) 
                if dZ==0:m=0 # les vitesses sont nulles à l'arrêt du jeu
                else:
                    k,K=dZ*dZ,X*dX+Y*dY 
                    m=(K+sqrt(K*K-k*(Z*Z-(d/2+D/2)*(d/2+D/2))))/k 
                x[i],y[i]=x[i]-m*dx[i],y[i]-m*dy[i]

                # algorithme de changement de direction des boules Bi après collision avec Cb 
                xx,xy,yy=X*X/Z/Z,X*Y/Z/Z,Y*Y/Z/Z 
                dx[i],dy[i]=(yy-xx)*dx[i]-2*xy*dy[i],-2*xy*dx[i]-(yy-xx)*dy[i]
            can.coords(B[i+1],x[i],y[i],x[i]+d,y[i]+d) # nouvelles coordonnées de Bi 
        # gestion de la COLLISION entre Bj et Bi: 
        for i in range(1,M): 
            for j in range(0,i): 
                if j!=i: 
                    X,Y=x[j]-x[i],y[j]-y[i] 
                    Z=hypot(X,Y) # distance entre les centres de Bj et Bi 
                    if Z<=d: # si cette distance est inférieure au diamètre (d) 
                        C+=1 # il y a collision (incrémentation du compteur C) 
                        CS=round(C/(time()-T+0.01),2) # calcul du nombre de collisions par seconde, depuis le départ 

                        # algorithme de recul de Bj et Bi, sur leurs directions initiales, pour revenir au stricte contact Bj/Bi: 
                        dX,dY=dx[j]-dx[i],dy[j]-dy[i] 
                        dZ=hypot(dX,dY) 
                        if dZ==0:m=0 # les vitesses sont nulles à l'arrêt du jeu
                        else:
                            k,K=dZ*dZ,X*dX+Y*dY 
                            m=(K+sqrt(K*K-k*(Z*Z-d*d)))/k 
                        x[i],y[i],x[j],y[j]=x[i]-m*dx[i],y[i]-m*dy[i],x[j]-m*dx[j],y[j]-m*dy[j] 
                        
                        # deuxième passage de cet algorithme: 
                        # (une étude de la cinématique de la collision montre qu'après un "stricte contact", suivi du changement de direction des boules, 
                        # il peut exister des cas de figure où l'on se retrouve avec Z<d au coup suivant; 
                        # il s'en suit un phénomène d'adhérence, pouvant aller jusqu'à leur immobilisation temporaire. 
                        # Pour résoudre ce probléme, aussi simplement que possible, on a pris le parti de procéder à un recul supplémentaire pour revenir à Z>d) 
                        X,Y=x[j]-x[i],y[j]-y[i] 
                        Z=hypot(X,Y) 
                        if Z<=d: 
                            if dZ==0:m=0
                            else:
                                k,K=dZ*dZ,X*dX+Y*dY 
                                m=(K+sqrt(K*K-k*(Z*Z-d*d)))/k 
                            x[i],y[i],x[j],y[j]=x[i]-m*dx[i],y[i]-m*dy[i],x[j]-m*dx[j],y[j]-m*dy[j] 
  
                        # algorithme de changement de direction des boules Bj et Bi après collision 
                        xx,xy,yy=X*X/Z/Z,X*Y/Z/Z,Y*Y/Z/Z 
                        dx[i],dy[i],dx[j],dy[j]=yy*dx[i]-xy*dy[i]+xx*dx[j]+xy*dy[j],-xy*dx[i]+xx*dy[i]+xy*dx[j]+yy*dy[j],xx*dx[i]+xy*dy[i]+yy*dx[j]-xy*dy[j],xy*dx[i]+yy*dy[i]-xy*dx[j]+xx*dy[j] 
  
                        can.C.config(text='%s'%C) # visualisation du compteur de collisions (C) 
                        can.CS.config(text='%s'%CS) # visualisation du compteur de collisions par seconde (CS) 
    root.after(10,tirer) 
 
def stop(): 
    "" 
    global flag,d
    flag=0 
    Bouton_tirage.config(state=ACTIVE)
#    Bouton_tirer.config(state=ACTIVE)
    can.delete(ALL) # effacement du contenu de la fenêtre 
    MM.delete(0,M) 
    texte=can.create_text(L/2,L/3,text='MERCI\n\nvous pouvez continuer en modifiant le nombre de boules\n\nou, tout simplement, arrêter !!!',fill="white") 
    d=d

######## Programme principal ############################################ 
  
# Création du widget principal : 
root = Tk() 
root.title('>>>>>>> COLLISIONS en cascades <<<<<<<') 
  
# données initiales: 
L=800 # longueur du jeu 
H=L # largeur du jeu 
d=50 # diamètre de la première boule 
D=L/6 # diamètre du cercle blanc
f,s=0.999,0.3 # coefficient de freinage et seuil d'arrêt 
M,C,CC=0,0,0 # compteurs de boules et de collisions 
flag=0 
# création des widgets "dépendants" : 
can=Canvas(root,bg='dark green',height=H,width=L) 
can.grid(row=1,column=0,rowspan=2) 
can2=Canvas(root,bg='brown',highlightbackground='brown') 
can2.grid(row=1,column=1,sticky=N) 
  
S=Button(can2,text='Stop !',height=2,width=25,relief=GROOVE,bg="white",activebackground="dark green",activeforeground="white",command=stop) 
S.pack(padx=5,pady=5,side=BOTTOM,anchor=SW) 
  
can.CS=Label(can2,text='0',fg='white',bg='brown') 
can.CS.pack(side=BOTTOM) 
Label(can2,text="Collisions par seconde",fg='white',bg='brown').pack(side=BOTTOM) 
  
can.C=Label(can2,text='0',fg='white',bg='brown') 
can.C.pack(side=BOTTOM) 
Label(can2,text="Nombre de collisions",fg='white',bg='brown').pack(side=BOTTOM) 
  
Bouton_tirer=Button(can2,text='Tirer !',height=2,width=25,relief=GROOVE,bg="white",activebackground="dark green",activeforeground="white",state=DISABLED,command=tirer) 
Bouton_tirer.pack(padx=5,pady=5,side=BOTTOM,anchor=SW) 
Bouton_tirage=Button(can2,text='Mettre les boules en place !',height=2,width=25,relief=GROOVE,bg="white",activebackground="dark green",activeforeground="white",state=ACTIVE,command=tirage) 
Bouton_tirage.pack(padx=5,pady=5,side=BOTTOM,anchor=SW) 
  
MM=Entry(can2) 
MM.pack(padx=8,pady=5,side=BOTTOM) 
Label(can2,text="Choisir le nombre de boules\n(jusqu'à 100)",fg='white',bg='brown').pack(side=BOTTOM) 
  
root.mainloop()

Conclusion :


Le problème des collisions fait l'objet d'une littérature abondante, mais difficile d'accès.
Si des amateurs se manifestent,je suis prêt à approfondir le phénomène d'adhérence qui s'observe dans certaines configurations de positions et de vitesses des objets.

Commentaires et cotations seront les bienvenus !!!
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (HCD)