Discussion :

[psgarsenal]

Bonjour a tous!
Avec un ami, nous créons un air hockey en lua pour psp, et nous somme confrontés à un problème: comment faire les rebonds entre le joueur et la balle?
nous arrivons à déplacer la balle selon un angle et une vitesse, a faire les rebonds sur les bords, mais ils nous reste un problème avec le joueur, lui aussi circulaire. Comment calculer l'angle de la tangente au cercle pour pouvoir effectuer un rebonds avec la loi de Snell-Descartes?
Merci de m'avoir lu ^^'

[nouknouk]

Salut,

un exemple de code en Javascript pour gérer une collision entre deux cercles.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
    function manageCollision () {
           // balles a et b avec attributs de position (x,y)
           // vitesse (vx,vy), 
           // coef d'absorption d'énergie au moment du choc (molesse)
            var a = { /* ... */ };
            var b = { /* ... */ };
 
            var vitessesX = a.vx - b.vx;
            var vitessesY = a.vy - b.vy;
            var positionsX = a.x - b.x;
            var positionsY = a.y - b.y;
 
            var scalaireAB = (vitessesX * positionsX) + (vitessesY * positionsY);
 
            if (scalaireAB > 0) {
                return false; // les deux balls s'éloignent.
            }
 
            var vabLength = Math.sqrt( (positionsX * positionsX) + (positionsY * positionsY) );
 
            var VabNormalizedX = (positionsX / vabLength);
            var VabNormalizedY = (positionsY / vabLength);
 
            var VabNormalizedScalaireA = ( (VabNormalizedX * a.vx) + (VabNormalizedY * a.vy));
            var VabNormalizedScalaireB = ( (VabNormalizedX * b.vx) + (VabNormalizedY * b.vy));
 
            var VaScalairizedX = (VabNormalizedX * VabNormalizedScalaireA);
            var VaScalairizedY = (VabNormalizedY * VabNormalizedScalaireA);
            var VbScalairizedX = (VabNormalizedX * VabNormalizedScalaireB);
            var VbScalairizedY = (VabNormalizedY * VabNormalizedScalaireB);
 
            var resX = VbScalairizedX - VaScalairizedX;
            var resY = VbScalairizedY - VaScalairizedY;
 
            var coefMolesse = (a.molesse + b.molesse) / 2;
 
            a.vx = ((a.vx + resX) / coefMolesse);
            a.vy = ((a.vy + resY) / coefMolesse);
            b.vx = ((b.vx - resX) / coefMolesse);
            b.vy = ((b.vy - resY) / coefMolesse);
    }

[psgarsenal]

merci, mais non ^^'
je cherche un moyen de calculer l'angle de la tengente au cercle du joueur, pour pouvoir continuer de diriger mes objets grace à un angle et une vitesse :/

[nouknouk]

Souvent, un petit schéma pour expliquer ce que tu cherches exactement vaut mieux qu'un long discours

[psgarsenal]

je voudrais calculer l'angle de la droite rouge, pour pouvoir ensuite calculer l'angle entre la droite verte et un des segments bleus (sachant que les deux segments bleus ont le même angle par rapport à la droite verte)

[nouknouk]

Ton schéma ne me paraît pas exact: si la 'droite' bleue représente le centre du palais, elle ne pourra jamais toucher le bord du cercle du joueur : il y a toujours un rayon de palais d'épaisseur au moment de la collision entre les deux éléments.

[psgarsenal]

le trait bleu est la trajectoire a partir du bords (oui, jme suis loupé ^^' )

[nouknouk]

Si j'ai bien compris, tu cherches à déterminer à l'avance la position exacte du centre du palais (*) au moment où l'impact aura lieu, 't'. Une fois ce 't' trouvé, il sera facile de recalculer les position respectives de chaque cercle, donc de déterminer la ligne entre les deux centres, donc de sa tangente.

Et trouver ce 't' revient à résoudre l'équation qui dit que la distance entre le centre des deux cercles devient égal au rayon du cercle 1 + rayon du cercle 2.
La distance entre les deux centres dépend des positions initiales + vitesses de chaque cercle + du temps t.

A toi de trifouiller cette égalité pour mettre d'un côté la variable t (ta seule vraie inconnue) qui sera alors exprimée en fonction de tout le reste situé de l'autre côté de l'égalité (ce 'reste' que tu connais lorsque ton programme s'exécute).


(*) parce quand il y aura un impact, les centres des deux cercles et le point où ceux-ci se touchent sont alignés.

[psgarsenal]

je vois voir ça, merci

[nouknouk]

Quelques URL utiles:

http://www.gamedev.net/topic/571214-calculating-sphere-collision/

http://twobitcoder.blogspot.fr/2010/...detection.html

[LittleWhite]

Bonjour,

Euh, la droite rouge ne sert à rien pour moi
La verte est la normale au cercle pour un point P (P étant un point sur le périmètre du cercle). Pour faire le rebond, comme pour la lumière, il faut faire V * N (V, le vecteur de votre balle et N, la normale donc).
Pour calculer la normale pour une sphère, c'est juste P - C (C étant le centre de la sphère et P toujours mon point sur le rayon). Et là, bah je crois que j'ai tout dit.
Pour trouver P, il suffit de faire un test de collision sphère/rayon que l'on trouvera partout sur internet.

[fifafou]

j'ai aussi cherché sur ce probleme
en utilisant un vecteur polaire(bien plus pratique) j'ai trouvé pour une balles fixe et une balle libre
Tu trouve la nouvelle direction avec vo=2*(atan2(y-yf,x-xf)+(pi/2.0))-vo
x,y étant les coordonnés de la balle libre
xf,yf celles de la fixe
et vo la direction de ta balle
voici mon code python
La vitesse ne change pas

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
from Tkinter import *
from math import *
fen=Tk()
fen.title("boules")
fon=Canvas(fen,height=400,width=400,bg="white")
fon.pack()
fen.geometry("400x400")
fon.create_oval(150,150,250,250,fill="black")
vr,vo=3.0,(input("angle")/180.0)*pi
y,x=0,-200.0
ro=fon.create_oval(x+150,y+150,x+200,y+200,fill="red")
def running():
    global x,y,vr,vo
    fon.coords(ro,x+150,y+150,x+250,y+250)
    x+=vr*cos(vo)
    y+=vr*sin(vo)
    if x>200 or x<-200:
        vo=pi-vo
    if y>200 or y<-200:
        vo=-vo
    if x**2+y**2<10000:
        vo=2*(atan2(y,x)+(pi/2.0))-vo#calcul de nouvelle position
    fen.after(5,running)
running()
fen.mainloop()