# Discussion: Collision de disques

1. ## Collision de disques

Bonjour,

J'ai écris ce petit script en python, utilisant pygame pour simuler des collisions de disques :

 Code : Sélectionner tout - Visualiser dans une fenêtre à part
```123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127###### BALLE REBONDISSANTE PAR CEDRIC B ######

import pygame
from math import sqrt
from pygame.locals import *

pygame.init()

# Defining some colors
black = (0,0,0)
white = (255,255,255)
green = (0,255,0)
red = (255,0,0)
gray=(115,115,115)

# Defining some constants
WIDTH = 900
HEIGHT = 650

# Defining some variables
x_pos=850
y_pos=325
dx,dy=25,-15

# Set the height and width and title of the screen
size=[WIDTH,HEIGHT]
screen=pygame.display.set_mode(size, pygame.HWSURFACE)
pygame.display.set_caption("Flipper")

#Loop until the user clicks the close button
done=False

# Used to manage how fast the screen updates
clock=pygame.time.Clock()

def Draw():
global x_pos, y_pos
screen.fill(white)
pygame.draw.circle(screen, red, (x_pos,y_pos),20,0)
pygame.draw.circle(screen, green, (300,275), 70,0)
pygame.draw.circle(screen, green, (600,275), 70,0)
pygame.draw.circle(screen, green, (450,450), 70,0)

def Move():
global x_pos, y_pos, dx, dy
x_pos,y_pos = x_pos+dx,y_pos+dy
if (x_pos>880 and dy>0):
x_pos, dx, dy = 880,-dx,dy
if (x_pos>880 and dy<0):
x_pos, dx, dy = 880,-dx,dy
if (y_pos>630 and dx>0):
y_pos, dx, dy=630,dx,-dy
if (y_pos>630 and dx<0):
y_pos, dx, dy=630,dx,-dy
if (x_pos<20 and dy>0):
x_pos, dx, dy = 20,-dx,dy
if (x_pos<20 and dy<0):
x_pos, dx, dy = 20,-dx,dy
if (y_pos<20 and dx>0):
y_pos, dx, dy=20,dx,-dy
if (y_pos<20 and dx<0):
y_pos, dx, dy=20,dx,-dy

d1=(300-x_pos)**2+(275-y_pos)**2
if (d1<8100):
pygame.draw.circle(screen, red, (300,275), 70,0)
unx=(x_pos-300)/sqrt((300-x_pos)**2+(275-y_pos)**2)
uny=(y_pos-275)/sqrt((300-x_pos)**2+(275-y_pos)**2)
utx=-uny
uty=unx
vn=unx*dx+uny*dy
vt=utx*dx+uty*dy
vn=(-99*vn)/101
vnx=vn*unx
vny=vn*uny
vtx=vt*utx
vty=vt*uty
dx=vnx+vtx
dy=vny+vty

d2=(450-x_pos)**2+(450-y_pos)**2
if (d2<8100):
pygame.draw.circle(screen, red, (450,450), 70,0)
unx=(x_pos-450)/sqrt((450-x_pos)**2+(450-y_pos)**2)
uny=(y_pos-450)/sqrt((450-x_pos)**2+(450-y_pos)**2)
utx=-uny
uty=unx
vn=unx*dx+uny*dy
vt=utx*dx+uty*dy
vn=(-99*vn)/101
vnx=vn*unx
vny=vn*uny
vtx=vt*utx
vty=vt*uty
dx=vnx+vtx
dy=vny+vty

d3=(600-x_pos)**2+(275-y_pos)**2
if (d3<8100):
pygame.draw.circle(screen, red, (600,275), 70,0)
unx=(x_pos-600)/sqrt((600-x_pos)**2+(275-y_pos)**2)
uny=(y_pos-275)/sqrt((600-x_pos)**2+(275-y_pos)**2)
utx=-uny
uty=unx
vn=unx*dx+uny*dy
vt=utx*dx+uty*dy
vn=(-99*vn)/101
vnx=vn*unx
vny=vn*uny
vtx=vt*utx
vty=vt*uty
dx=vnx+vtx
dy=vny+vty

# -------- Main Program Loop ---------
while done==False:
for event in pygame.event.get():
if event.type == pygame.QUIT:
done=True
Draw()
Move()

clock.tick(30)
pygame.display.update()

pygame.quit()```
Bon, je sais, mon code n'est pas très optimisé, mais il semble fonctionner pendant une minute puis la petite balle rouge se colle au disque vert de gauche.

Je ne comprends pas pourquoi....

Auriez vous une solution?

Merci d'avance!

2. Pour info j'ai utilisé l'algorithme de ce pdf.

Ce sont des collisions élastiques et pourtant la vitesse de la balle rouge diminue au cours des collisions.

J'ai fixé la masse des disques verts à 100 et la masse du disque rouge à 1.

Cela me dépasse...

3. Salut,

L'impression que ça me donne d'après ta description, c'est que la balle rouge "rentre" à l'intérieur de la balle verte au step N, mais sa vitesse de rebond n'est plus suffisante pour en "ressortir" au step N+1. Elle reste donc collé dedans.

Lorsque tu calcul ton intersection, avant de calculer ta vitesse de rebond il faut que tu remette ta balle rouge au point de contact avec la balle verte pour éviter ce genre de problème "d'aliasing".

4. Salut et merci pour le coup de pouce !

Ce problème de collision disque/disque est plutôt difficile, je trouve, mais j'en apprends pas mal sur la programmation, surtout en algorithmique, en essayant de le coder.

En effet, je constate que, bien qu'il soit analytiquement simple, il réserve des surprises numériques comme celui que j'ai décrit précédemment. Pire. En changeant la vitesse initiale, je constate qu'il arrive que le disque se colle à un vert, puis tourne autour de celui-ci, puis se détache complètement pour continuer sa trajectoire et ses collisions....

J'ai retravaillé mon code qui était bien cochon et voici une version procédurale du script :

 Code : Sélectionner tout - Visualiser dans une fenêtre à part
```123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112###### BALLE REBONDISSANTE PAR CEDRIC B ######

import pygame
from math import sqrt
from pygame.locals import *

pygame.init()

# Defining some colors
black = (0,0,0)
white = (255,255,255)
green = (0,255,0)
red = (255,0,0)
gray=(115,115,115)

# Defining screen dimension constants
WIDTH = 900
HEIGHT = 650

# Defining initial position and initial speed
position=[150,325]
speed=[25,29]

# Defining balls
redBall=(position, speed)
greenBall1=((300,275), 70)
greenBall2=((600,275), 70)
greenBall3=((450,450), 70)

# Set the height and width and title of the screen
size=[WIDTH,HEIGHT]
screen=pygame.display.set_mode(size, pygame.HWSURFACE)
pygame.display.set_caption("Collisions")

#Loop until the user clicks the close button
done=False

# Used to manage how fast the screen updates
clock=pygame.time.Clock()

def Draw(redBall, greenBall1,greenBall2,greenBall3):
screen.fill(white)
pygame.draw.circle(screen, red, (redBall[0][0],redBall[0][1]) ,20,0)
pygame.draw.circle(screen, green, greenBall1[0],greenBall1[1] ,0)
pygame.draw.circle(screen, green, greenBall2[0],greenBall2[1],0)
pygame.draw.circle(screen, green, greenBall3[0],greenBall3[1],0)

collideSquaredDistance=(center[0]-position[0])**2+(center[1]-position[1])**2
unitaryNormalVect=[(position[0]-center[0])/sqrt(collideSquaredDistance),(position[1]-center[1])/sqrt(collideSquaredDistance)]
unitaryTangentVect=[-unitaryNormalVect[1],unitaryNormalVect[0]]
normalSpeed=unitaryNormalVect[0]*speed[0]+unitaryNormalVect[1]*speed[1]
tangentSpeed=unitaryTangentVect[0]*speed[0]+unitaryTangentVect[1]*speed[1]
normalSpeed=(-99*normalSpeed)/101
normalSpeedVect=[normalSpeed*unitaryNormalVect[0],normalSpeed*unitaryNormalVect[1]]
tangentSpeedVect=[tangentSpeed*unitaryTangentVect[0],tangentSpeed*unitaryTangentVect[0]]
resultSpeed=[normalSpeedVect[0]+tangentSpeedVect[0],normalSpeedVect[1]+tangentSpeedVect[1]]
return resultSpeed
else:
return speed

def RectangularCollide(position, speed):
# rectangular collision with screen boundaries
if (position[0]>880 and speed[1]>0):
return (880, position[1],-speed[0],speed[1])
elif (position[0]>880 and speed[1]<0):
return (880,position[1],-speed[0],speed[1])
elif (position[1]>630 and speed[0]>0):
return (position[0], 630,speed[0],-speed[1])
elif (position[1]>630 and speed[0]<0):
return (position[0], 630,speed[0],-speed[1])
elif (position[0]<20 and speed[1]>0):
return (20, position[1],-speed[0],speed[1])
elif (position[0]<20 and speed[1]<0):
return (20, position[1],-speed[0],speed[1])
elif (position[1]<20 and speed[0]>0):
return (position[0], 20,speed[0],-speed[1])
elif (position[1]<20 and speed[0]<0):
return (position[0], 20,speed[0],-speed[1])
else:
return (position[0],position[1], speed[0],speed[1])

# -------- Main Program Loop ---------
while done==False:
for event in pygame.event.get():
if event.type == pygame.QUIT:
done=True
Draw(redBall, greenBall1,greenBall2,greenBall3)

position[0]+=speed[0]
position[1]+=speed[1]

rectCollideResult=RectangularCollide(position,speed)
position[0]=rectCollideResult[0]
position[1]=rectCollideResult[1]
speed[0]=rectCollideResult[2]
speed[1]=rectCollideResult[3]

speed=CircularCollide(position, speed, greenBall1[0], greenBall1[1])
speed=CircularCollide(position, speed, greenBall2[0], greenBall2[1])
speed=CircularCollide(position, speed, greenBall3[0], greenBall3[1])

clock.tick(30)
pygame.display.update()

pygame.quit()```
@ Pyros > Je ne m'y connais pas plus que cela en collision, je découvre, et je pense que tu as raison : le disque rouge se positionne dans l'un des disques verts puisque ma condition le lui permet. Par contre je ne vois pas pourquoi le disque peut se replacer à l'extérieur et continuer sa trajectoire. Etrange !

Aurais-tu une explication stp ?

De plus j'ai réfléchi toute une après-midi sur comment déterminer la position du disque rouge lorsque je veux le replacer à la surface d'un disque vert. Je connais la position et la vitesse au pas N mais comment faire pour calculer la position au pas N+1 ? En clair, comment supprimer cet effet génant ?

Merci !

5. Aurais-tu une explication stp ?
Là je vois pas. Mais comme tu es dans un cas qui n'est pas censé arriver (disque à l'intérieur d'une autre), il peut se passer plein de chose. C'est le principe même d'un bug

comment faire pour calculer la position au pas N+1 ?
Sans dessin ça vas être un peu compliquer à expliquer, mais je vais essayer quand même:

Tu détecte une collision entre 2 disque de centre O1 et O2, de rayon R1 et R2. En théorie (en analytique quoi ) la distance [O1, O2] = R1 + R2. Mais là, à cause de la discrétisation du mouvement, [O1, O2] < R1 + R2.
Tu dois donc repositionner l'un des disque de manière à ce que [O1, O2] = R1 + R2 + eps (+eps pour éviter le problèmes d'imprécisions et être sûr que les 2 disque ne sont pas l'un dans l'autre au moment du rebond).

Pour ce faire, c'est assez simple. Tu fait juste une translation sur O1 de:
(R1+R2 - ||O1 - O2|| + eps) * normalize(O1 - O2).
A vérifier quand même, je fait souvent des erreurs de signe

 Actualités LES FAQs TUTORIELS OUTILS BIBLIOTHEQUES MÉDIAS LIVRES SOURCES VIDÉOS BLOG