Java probleme de colision

[mysteriou]

je suis entrai de creer un cassebrique en java et je un probleme pour creer le moteur colision et je suis perdue tout vous sugestion sont les bienvenue.

[gruik]

comme ça au pied levé, on imagine que tu as un tableau ou une liste chainée avec toutes tes briques restantes avec leurs positions respectives, et à chaque déplacement de la balle ben tu parcoures ta liste pour vérifier si à la prochaine position de la balle elle sera en collision avec une case

[mysteriou]

gruik merci du conseil il voudrai un exemple Concret un code que je puisse utilser. merci d'avance

[notfound]

il voudrai un exemple Concret merci d'avance

Qui il ?

un code que je puisse utilser.

En gros, tu veux qu'on te fasse ton boulot de a à z ? Gruik t'a donné de bonnes pistes, je pense qu'il est préférable maintenant de le coder toi même.

[supersnail]

Comme dit NotFound, on veut bien être sympas et aider mais à un moment faut pas pousser mémé dans les orties et demander à ce qu'on code à ta place, c'est pas comme ça qu'on progresse.

[mysteriou]

je pas qu'au fasse le boulot a ma place je voulais juste un code qui explique son idéer

[Enila]

« Apprenez à bien écrire dans votre langue maternelle. Même si c'est un stéréotype commun que les programmeurs ne savent pas écrire, un nombre surprenant de hackers (incluant les plus accomplis que je connaisse) sont de très bon rédacteurs. »

Peut-être devrais-tu méditer sur cette citation, et creuser là-dessus.

[Junky]

Bonjour,

comme ça au pied levé, on imagine que tu as un tableau ou une liste chainée avec toutes tes briques restantes avec leurs positions respectives, et à chaque déplacement de la balle ben tu parcoures ta liste pour vérifier si à la prochaine position de la balle elle sera en collision avec une case

Tu as "l'algo" pour réaliser ton code. Tu as le plus important puisque en dev le "plus souvent" c'est le déroulement/algo a mettre en place qui est le plus dur...

Je trouve gruik très gentil de t'avoir donné la marche a suivre.
Tu n'as plus qu'a te mettre a coder... JE pense honnêtement que plutôt vouloir avoir ABSOLUMENT un bout de code de notre part, tu ferais mieux de commencer à coder toi même et si tu as des problèmes/erreurs x ou y post nous ton code via ici et tu verras que la communauté sera plus enclin à te répondre...
Là tu t'enfonces de jour en jour mec a mendier des exemples de codes que personnes ne te donnera...

Junky

[notfound]

je pas qu'au fasse le boulot a ma place je voulais juste un code qui explique son idéer

Non mais toplel, il le fait exprès !

[Sh4dows]

je pas qu'au fasse le boulot a ma place je voulais juste
un code qui explique son idéer

Et sans code ça marche aussi ?


MAP (tableau à double entrée par exemple):
000000000000000
011111111111110
011110000011110
000000000000X00
000000000000000

0 = vide
1 = brique
X = position de la balle

Admettons que ta balle soit actuellement en train de monter, en ce moment elle se situe sur le X, ce que tu devrais faire selon l'algo. de @gruik, c'est trouver la case sur laquelle la balle se situera après un déplacement mais ceci avant de la déplacer.

Une fois que tu as la prochaine case (ici le 1) il te suffit juste de vérifier si celle-ci est vide(0) ou contient une brique(1) puis de faire une action en fonction du résultat à savoir si je m'en souviens bien un rebond+cassage de la brique ou déplacement de la balle.

Par exemple si la case de destination est une brique, je la casse.
000000000000000
011111111111110
011110000011010
000000000000X00
000000000000000

Et je fais rebondir ma balle:
000000000000000
011111111111110
011110000011010
000000000000000
000000000000X00

So, code it !!!!

EDIT: -5mn de ma vie

[b0fh]

Salut,

Voici du code qui explique l'idée, en implémentant la collision d'objets ponctuels avec des solides.

Code HASKELL :


data Vector = Vector Double Double
data Point = Point Double Double

type Velocity = Vector

type Segment = (Point,Point)

type Geometry = [Point]

data Ball = Ball   { position :: Point,
                     velocity :: Velocity }

(->+) :: Vector -> Vector -> Vector
Vector x1 y1  ->+ Vector x2 y2  = Vector (x1+x2) (y1+y2)

(->*) :: Vector -> Double -> Vector
Vector x y ->* k = Vector (x*k) (y*k)

(.->) :: Point -> Vector -> Point
Point x y .-> Vector vx vy = Point (x+vx) (y+vy)

(-->) :: Point -> Point -> Vector -- from 2 points
Point x0 y0  --> Point x1 y1 = Vector (x1-x0) (y1-y0)

o :: Vector -> Vector -> Double -- scalar product
Vector x1 y1 `o` Vector x2 y2  = x1*x2 + y1*y2

x :: Vector -> Vector -> Double -- cross product
Vector x1 y1  `x` Vector x2 y2 = x1*y2 - x2*y1

normal :: Vector -> Vector
normal (Vector x y) = Vector y (0-x)

projection :: Vector -> Vector -> Vector
projection v0 v1 = v0 ->* ((v0 `o` v1) / (v0 `o` v0))

segments :: Geometry -> [Segment]
segments ps = zipWith (,) ps (tail ps ++ ps)

segvec :: Segment -> Vector
segvec (p0,p1) = p0 --> p1

move :: Ball -> Ball
move ball = Ball (position ball .-> velocity ball) (velocity ball)

bounce :: Ball -> Segment -> Ball
bounce ball seg = let
        old = position ball
        new = position (move ball)
    in if intersect seg (old,new)
        then
            let newvelocity = velocity ball ->+ (projection (normal (segvec seg)) (velocity ball) ->* (-2))
            in  Ball (position ball) (newvelocity)
        else
            ball

bounceMany :: Ball -> [Segment] -> Ball
bounceMany = (move.). foldl bounce

intersect :: Segment -> Segment -> Bool
intersect (p0,p1) (q0,q1) =
    let
        s = q0 --> q1
        r = p0 --> p1
        pq = p0 --> q0
        rxs = r `x` s
        t = (pq `x` s) / rxs
        u = (pq `x` r) / rxs
    in
        rxs /= 0 && 0 <= t && t <= 1 && 0 <= u && u <= 1

 

[thxer]

Google : Casse Brique Java.

[Jek0]

Google : Casse Brique Java.

Je dirais même plus : http://bit.ly/1cmjimf

[Enila]

Bon, tout ce qui était susceptible d'être intéressant a été dit.

Enjoy