Collision de disques

[frenchem67]

Bonjour,

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

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
###### 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!

[frenchem67]

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...

[pyros]

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".

[frenchem67]

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 :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
###### 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)
 
def CircularCollide(position, speed, center, radius):
    collideSquaredDistance=(center[0]-position[0])**2+(center[1]-position[1])**2
    if (collideSquaredDistance<(20+radius)**2):
        pygame.draw.circle(screen, red, center, radius,0)
        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 !

[pyros]

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