Accueil > > > COLLISIONS EN CASCADES : PLUS D'UNE CENTAINE DE BOULES S'ENTRECHOQUENT !
COLLISIONS EN CASCADES : PLUS D'UNE CENTAINE DE BOULES S'ENTRECHOQUENT !
Information sur la source
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
- #! /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()
-
#! /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 !!!
Historique
- 02 décembre 2005 01:19:47 :
- Ajout d'un cercle infranchissable au centre du jeu.
Amélioration du code pour gérer la fin des mouvements.
(éviter les divisions par zéro...qui génèrent des exceptions).
Amélioration des commentaires.
- 19 décembre 2005 22:12:41 :
- Cette mise à jour corrige deux points :
1. l' accélération intempestive du mouvement lors de clics successifs sur les boutons < Mettre les boules en place ! > et< Tirer ! >.
(La solution a consisté à mettre en oeuvre l'option "state" (ACTIVE ou DISABLED) de ces deux widgets)
2. le système de comptage (nombre de collisions et nombre de collisions/seconde)dont l'affichage ne revenait pas à zéro après un "stop".
Un zip est enfin ajouté.
- 25 juin 2006 11:27:51 :
- Ajout d'un ZIP et d'une capture d'écran
Sources du même auteur
Sources de la même categorie
Commentaires et avis
|
Derniers Blogs
[MIX10] KEYNOTE DEUXIèME JOURNéE - INTERNET EXPLORER 9, HTML5, VISUAL STUDIO 2010, ODATA[MIX10] KEYNOTE DEUXIèME JOURNéE - INTERNET EXPLORER 9, HTML5, VISUAL STUDIO 2010, ODATA par cyril
Le deuxième keynote du mix fut très riche en contenu. Internet Explorer 9 Juste un après le lancement de Internet Explorer 8, Microsoft a dévoilé les nouveautés de Internet Explorer 9. Désormais, IE supportera HTML5, SVG et CSS3. L'élément ...
Cliquez pour lire la suite de l'article par cyril CERTIFICATIONS BETA .NET 4CERTIFICATIONS BETA .NET 4 par KooKiz
Les inscriptions pour les certifications beta .NET 4 ont commencé. L'inscription est offerte pour les examens suivants : - 71-511, TS: Windows Applications Development with Microsoft .NET Framework 4 - 71-515, TS: Web Applications Development with...
Cliquez pour lire la suite de l'article par KooKiz [MIX 2010] - MICROSOFT TRANSLATOR TECHNOLOGY PREVIEW V2[MIX 2010] - MICROSOFT TRANSLATOR TECHNOLOGY PREVIEW V2 par redo
J'imagine que la plupart d'entre vous connaissent bien et utilisent le service de traduction de Google, mais connaissez-vous celui de Microsoft . Microsoft Translator ? Effectivement, Microsoft nous annoncé le lancement version 2 de la Technologie Preview...
Cliquez pour lire la suite de l'article par redo LANCEMENT EN PREVIEW DE CYCLONE LORS DES TECHDAYS 2010!LANCEMENT EN PREVIEW DE CYCLONE LORS DES TECHDAYS 2010! par MPOWARE
Toutes les vidéos de ce lancement sont en ligne!
Partie I - Intro
http://www.youtube.com/watch?v=LkQzTQ8T6CA
Partie II - Démo 1
http://www.youtube.com/watch?v=drAhYQ7lqvo
Partie III - Démo 2
http://www.youtube.com/watch?v=c8KM_1Gqybc...
Cliquez pour lire la suite de l'article par MPOWARE
Logiciels
Academy System (10.9.4.0)ACADEMY SYSTEM (10.9.4.0)Logiciel de gestion des établissements.
- élèves/étudiants (inscription, dossier, absence...)
-... Cliquez pour télécharger Academy System Xilisoft Convertisseur Vidéo Ultimate (5.1.39.0305)XILISOFT CONVERTISSEUR VIDéO ULTIMATE (5.1.39.0305)Xilisoft Convertisseur Vidéo Ultimate est un outil puissant de conversion vidéo, facile à utilise... Cliquez pour télécharger Xilisoft Convertisseur Vidéo Ultimate Xilisoft DVD Ripper Ultimate (5.0.64.0304)XILISOFT DVD RIPPER ULTIMATE (5.0.64.0304)Xilisoft DVD Ripper Ultimate est un logiciel excellent pour copier et convertir DVD vers presque ... Cliquez pour télécharger Xilisoft DVD Ripper Ultimate Rigs of Rods (63.3)RIGS OF RODS (63.3)c'est un jeu de multi-simulation camions,autobus voitures, avions, bateaux, hélicoptère avec défo... Cliquez pour télécharger Rigs of Rods
|