Discussion :

[Ouaibou]

Bonsoir,

Ca peut paraître bête mais voila je suis en train de réaliser un jeu de casse brique en scheme, et j'ai un léger soucis pour détecter les collisions entre deux rectangles et plus précisemment pour savoir sur quel côté de la brique la balle a tapé.

J'ai donc une brique qui est un rectangle et une balle qui est un carré (donc un rectangle).

Pour détecter si il y a une collision, j'utilise 4 clauses (c1, c2, c3, c4) permettant de vérifier si la balle est bien à l'intérieur de la brique.

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
(define (brick-collision list)
      (do ((bricks list (cdr bricks)) (i 0 (+ i 1)))
        ((null? bricks) (void))
        (let* ((brick (car bricks))
               (brick-x (send brick get-x))
               (brick-y (send brick get-y))
               (brick-w (send brick get-width))
               (brick-h (send brick get-height))
               (brick-x-max (+ brick-x brick-w))
               (brick-y-max (+ brick-y brick-h))
               (ball-x-max (+ x (* ray 2)))
               (ball-y-max (+ y (* ray 2)))
               ;; Différentes clauses devant etre verifiées
               ;; pour qu'une collision ai lieu
               (c1 (and (is-between ball-x-max brick-x brick-x-max)
                        (is-between ball-y-max brick-y brick-y-max)))
               (c2 (and (is-between ball-x-max brick-x brick-x-max)
                        (is-between y brick-y brick-y-max)))
               (c3 (and (is-between x brick-x brick-x-max)
                        (is-between ball-y-max brick-y brick-y-max)))
               (c4 (and (is-between x brick-x brick-x-max)
                        (is-between y brick-y brick-y-max))))
 
          (when (or c1 c2 c3 c4)
            (printf "Collision detectée\n")
            (if c2 ;; ? collision sur côté haut/bas
              (set! dy (- dy)))
            (if c3 ;; ? collision sur côté gauche/droite
                (set! dx (- dx)))
            (send CURRENT-LEVEL set-bricks (list-delete list i))))))

Une fois ceci fait je souhaitais savoir si la balle a tapé contre le côté gauche/droit, haut/bas ou sur un angle de la brique pour modifier la direction (vecteur vitesse de la balle : dx, dy) de la balle en conséquence, mais c'est ici que je bloque.

Ma méthode de détection des collisions est t-elle correcte? Existe-t-il plus simple, plus rapide, et surtout quelqu'un saurait-il m'indiquer comment une fois la collision détecter, savoir ou la balle a tapé ?

Merci.

Cordialement,
Laurent

[Ouaibou]

Personne n'aurait une petite idée ou une adresse, etc. ?

[pseudocode]

Personne n'aurait une petite idée ou une adresse, etc. ?

Si, plein d'idée. C'est juste le cote "lisp" qui bloque.

Une idée comme ca:
- verifier la collision aux 2 extremités gauche(1) et droite(2) de la balle.

Code :

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

1
2
3
4
5
6
7
 
__        ___________ _____ __ _ 
__|      |___________|_____ __ _ 
 
     1__2
     |  |
     |__|

- si les 2 extremités sont dans un intervalle (brick-x,brick-x-max), alors la balle a tapé au milieu d'un mur de briques ==> on conserve le "dx" initial, on change le signe de "dy"

- si une des 2 extremités est hors des intervalles (brick-x,brick-x-max), alors la balle a tapé au bord d'un mur de briques ==> on change le signe de "dx" et de "dy"

- si aucune des 2 extremités est dans un intervalle (brick-x,brick-x-max), alors il n'y a pas d'obstace ==> on conserve le "dx" et le "dy" initial

[Ouaibou]

Tout d'abord merci pour ta réponse.

Pour les changement de direction c'est ce que j'avais écrit en Scheme.
Ton algo prend en cas une face de la brique, mais comment faire pour tester toutes les faces avec le moins de tests possibles.

Code :

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

1
2
3
4
5
6
1       2
 ------
 |     |
 |     |
  ------
3     4

Le soucis étant que la balle peut taper une brique depuis n'importe quel côté sur n'importe quel côté de la brique. Ce qui fait 16 cas.

[pseudocode]

Ton algo prend en cas une face de la brique, mais comment faire pour tester toutes les faces avec le moins de tests possibles.

Tu n'as pas besoin de tester tous les cas a en permanence. Selon la direction de la balle, seuls 1 ou 2 cas sont a tester.

La balle peut se deplacer dans 8 directions qui correspondent aux valeurs de dx et dy suivantes:

dx=0 et dy<0 <==> Haut
dx<0 et dy<0 <==> Haut+Gauche
dx>0 et dy<0 <==> Haut+Droite
...

Quand la balle va vers le Haut, tu dois tester les collisions des extremités (1) et (2) avec le bas des briques

Quand la balle va vers la Gauche, tu dois tester les collisions des extremités (1) et (3) avec la droite des briques

Quand la balle va vers le Haut+Gauche, tu dois tester les 2 cas.