[JAVA] Collisions

[invite1bcc2991]

Bonjour,

J'aimerai simuler une situation où des boules se déplaceraient à vitesse constante et où elles se cogneraient pour rebondir les unes sur les autres sur le plan (O,X,Y).

De ce fait, j'ai pu modéliser avec une arborescence de classes JAVA dont voici les codes:

PACKAGE collisions

package collisions;

public class Point
{
    public final static Point O=new Point(0, 0);
    final double x;
    final double y;

    public Point(double x, double y)
    {
        this.x=x;
        this.y=y;
    }

    public final double x()
    {
        return x;
    }

    public final double y()
    {
        return y;
    }
}

package collisions;

public interface ObjetCollision
{
}

package collisions;

public class Droite
{
    final Point a;
    final Point b;
    final double p;
    final double o;

    public Droite(Point a, Point b)
    {
        this.a=a;
        this.b=b;
        p=(a.y-b.y)/(a.x-b.x);
        o=(a.y+b.y)/2-p*(a.x+b.x)/2;
    }

    public Droite(double p, double o)
    {
        this.a=new Point(0, o);
        this.b=new Point(1, p+o);
        this.p=p;
        this.o=o;
    }

    @Override
    public /*final*/ String toString()
    {
        return "Droite passant par les deux points suivants: "+a+" et "+b+".";
    }

    public final Point a()
    {
        return a;
    }

    public final Point b()
    {
        return b;
    }

    public final double p()
    {
        return p;
    }

    public final double o()
    {
        return o;
    }

    public boolean isHorizontal()
    {
        return a.y==b.y;
    }

    public boolean isVertical()
    {
        return a.x==b.x;
    }

    public final Point projection(Point p) //vérifié
    { //point allant en perpendiculaire sur la droite en partant du point
        Point A=a;
        Point B=b;
        Point C=p;

        Vecteur u=new Vecteur(B.x-A.x, B.y-A.y);
        Vecteur AC=new Vecteur(C.x-A.x, C.y-A.y);
        double ti=(u.x*AC.x+u.y*AC.y)/(u.x*u.x+u.y*u.y);
        return new Point(A.x+ti*u.x, A.y+ti*u.y);
    }

    public final Vecteur normale(Point p) //vérifié
    {
        Point A=a;
        Point B=b;
        Point C=p;

        Vecteur u=new Vecteur(B.x-A.x, B.y-A.y);
        Vecteur AC=new Vecteur(C.x-A.x, C.y-A.y);
        double parenthesis=u.x*AC.y-u.y*AC.x;
        Vecteur N=new Vecteur(-u.y*parenthesis, u.x*parenthesis);
        double norme=Math.sqrt(N.x*N.x+N.y*N.y);
        Vecteur NN=new Vecteur(N.x/norme, N.y/norme);
        return NN;
    }

    public final Point perpendiculaire(Point p, double x)
    {
        double pp=-1/this.p;
        double oo=p.y+p.x/this.p;
        double y=x*pp+oo;
        return new Point(x, y);
    }
}

package collisions;

public class Segment extends Droite implements ObjetCollision
{
    public Segment(Point a, Point b)
    {
        super(a, b);
    }

    //nous sommes un point O, nous voulons avancer vers P, Touchons-nous le segment[AB]?
    //this=[OP]
    //d=(AB)
    //s=[AB]
    public final boolean collision(Droite d) //verifié
    {
        Point A=d.a;
        Point B=d.b;
        Point O=this.a;
        Point P=this.b;

        Vecteur AB=new Vecteur(B.x-A.x, B.y-A.y);
        Vecteur AP=new Vecteur(P.x-A.x, P.y-A.y);
        Vecteur AO=new Vecteur(O.x-A.x, O.y-A.y);
        return (AB.x*AP.y-AB.y*AP.x)*(AB.x*AO.y-AB.y*AO.x)<0;
    }

    public final boolean collision(Segment s) //vérifié
    {
        if (!collision((Droite)s))
        {
            return false;
        }
        /*if (!s.collision((Droite)this))
        {
            return false;
        }
        //return true;*/

        Point A=s.a;
        Point B=s.b;
        Point O=this.a;
        Point P=this.b;

        Vecteur AB=new Vecteur(B.x-A.x, B.y-A.y);
        Vecteur OP=new Vecteur(P.x-O.x, P.y-O.y);
        double k=-(A.x*OP.y-O.x*OP.y-OP.x*A.y+OP.x*O.y)/(AB.x*OP.y-AB.y*OP.x);
        return !(k<0||k>1);
    }
}

package collisions;

public class Vecteur
{
    final double x;
    final double y;
    final Point p;

    public Vecteur(double x, double y)
    {
        this.x=x;
        this.y=y;
        p=new Point(x, y);
    }

    public Vecteur(Point p)
    {
        this.p=p;
        x=p.x;
        y=p.y;
    }

    public final double x()
    {
        return x;
    }

    public final double y()
    {
        return y;
    }

    public final Point p()
    {
        return p;
    }

    public final Vecteur rebond(Vecteur n) //vérifié
    {
        Vecteur N=n;
        Vecteur v=this;
        double pscal=(v.x*N.x+v.y*N.y);
        return new Vecteur(v.x-2*pscal*N.x, v.y-2*pscal*N.y);
    }

    public final double getAngle()
    {
        return getAngle(true);
    }
    
    public final double getAngle(boolean degre)
    {
        double module=Math.sqrt(x*x+y*y);
        double cosinus=x/module;
        double sinus=y/module;
        double argument=0;
        if (module!=0)
        {
            switch (quadrant(cosinus, sinus))
            {
                case 1:
                case 2:
                    argument=Math.acos(cosinus);
                    break;
                case 3:
                case 4:
                    argument=2*Math.PI-Math.acos(cosinus);
                    break;
            }
        }
        if (degre)
        {
            argument=(argument*180)/Math.PI;
        }
        return argument;
    }
    
    private static int quadrant(double cosinus, double sinus)
    {
        int quadrant=0;
        if (cosinus>=0&&sinus>=0)
        {
            quadrant=1;
        }
        else if (cosinus<0&&sinus>=0)
        {
            quadrant=2;
        }
        else if (cosinus<0&&sinus<0)
        {
            quadrant=3;
        }
        else if (cosinus>=0&&sinus<0)
        {
            quadrant=4;
        }
        return quadrant;
    }
    
    public static Vecteur getAngle(double angle)
    {
        return getAngle(angle, 1, true);
    }

    public static Vecteur getAngle(double angle, double etendue)
    {
        return getAngle(angle, etendue, true);
    }

    public static Vecteur getAngle(double angle, boolean degre)
    {
        return getAngle(angle, 1, degre);
    }

    public static Vecteur getAngle(double angle, double etendue, boolean degre)
    {
        if (degre)
        {
            angle=(angle*Math.PI)/180;
        }
        return new Vecteur(etendue*Math.cos(angle), etendue*Math.sin(angle));
    }
}

package collisions;

public class Rectangle implements ObjetCollision
{
    final Point p;
    final double w;
    final double h;
    final double x;
    final double y;

    public Rectangle(Point p, double w, double h)
    {
        this.p=p;
        this.w=w;
        this.h=h;
        this.x=p.x;
        this.y=p.y;
    }

    public Rectangle(double x, double y, double w, double h)
    {
        this.p=new Point(x, y);
        this.w=w;
        this.h=h;
        this.x=x;
        this.y=y;
    }

    public final Point p()
    {
        return p;
    }

    public final double w()
    {
        return w;
    }

    public final double h()
    {
        return h;
    }

    public final double x()
    {
        return x;
    }

    public final double y()
    {
        return y;
    }

    public final boolean collision(Point p) //vérifié
    {
        double curseur_x=p.x;
        double curseur_y=p.y;
        Rectangle box=this;

        return curseur_x>=box.x
                &&curseur_x<box.x+box.w
                &&curseur_y>=box.y
                &&curseur_y<box.y+box.h;
    }

    public final boolean collision(Rectangle r) //verifié
    {
        Rectangle box1=this;
        Rectangle box2=r;

        return !(box2.x>=box1.x+box1.w
                ||box2.x+box2.w<=box1.x
                ||box2.y>=box1.y+box1.h
                ||box2.y+box2.h<=box1.y);
    }

    public final boolean collision(Cercle c)
    {
        return c.collision(this);
    }

    public final boolean collision(Segment s)
    {
        return getNord().collision(s)||getSud().collision(s)||getOuest().collision(s)||getEst().collision(s);
    }

    public final Segment getNord()
    {
        return new Segment(new Point(p.x, p.y), new Point(p.x+w, p.y));
    }

    public final Segment getSud()
    {
        return new Segment(new Point(p.x, p.y+h), new Point(p.x+w, p.y+h));
    }

    public final Segment getOuest()
    {
        return new Segment(new Point(p.x, p.y), new Point(p.x, p.y+h));
    }

    public final Segment getEst()
    {
        return new Segment(new Point(p.x+w, p.y), new Point(p.x+w, p.y+h));
    }

    public final Vecteur rebondir(Segment segment, Vecteur direction)
    {
        if (collision(segment))
        {
            Vecteur normale=segment.normale(new Point(x+w/2, y+h/2));
            direction=direction.rebond(normale);
        }
        return direction;
    }

    public final Vecteur rebondir(Rectangle rectangle, Vecteur direction)
    {
        Vecteur dir;
        dir=rebondir(rectangle.getNord(), direction);
        if (dir!=direction)
        {
            return dir;
        }
        dir=rebondir(rectangle.getSud(), direction);
        if (dir!=direction)
        {
            return dir;
        }
        dir=rebondir(rectangle.getOuest(), direction);
        if (dir!=direction)
        {
            return dir;
        }
        dir=rebondir(rectangle.getEst(), direction);
        if (dir!=direction)
        {
            return dir;
        }
        return direction;
    }
}

-----

[invite1bcc2991]

package collisions;

public class Cercle implements ObjetCollision
{
    final Point p;
    final double r;
    final double x;
    final double y;

    public Cercle(Point p, double r)
    {
        this.p=p;
        this.r=r;
        this.x=p.x;
        this.y=p.y;
    }

    public Cercle(double x, double y, double r)
    {
        this.p=new Point(x, y);
        this.r=r;
        this.x=x;
        this.y=y;
    }

    public final Point p()
    {
        return p;
    }

    public final double r()
    {
        return r;
    }

    public final double x()
    {
        return x;
    }

    public final double y()
    {
        return y;
    }

    public final Rectangle getRectangle()
    {
        return new Rectangle(x-r, y-r, 2*r, 2*r);
    }

    public final boolean collision(Point p) //vérifié
    {
        double x=p.x;
        double y=p.y;
        Cercle C=this;

        double d2=(x-C.x)*(x-C.x)+(y-C.y)*(y-C.y);
        return d2<=C.r*C.r;
    }
    
    public final boolean collision(Rectangle r)
    {
        return collision(r.getNord())||collision(r.getSud())||collision(r.getOuest())||collision(r.getEst()); // /!\ C'est moche et ça peut bugger...
    }

    public final boolean collision(Cercle c) //vérifié
    {
        Cercle C1=this;
        Cercle C2=c;

        double d2=(C1.x-C2.x)*(C1.x-C2.x)+(C1.y-C2.y)*(C1.y-C2.y);
        return d2<=(C1.r+C2.r)*(C1.r+C2.r);
    }

    public final boolean collision(Droite d) //vérifié
    {
        Point A=d.a;
        Point B=d.b;
        Cercle C=this;

        Vecteur u=new Vecteur(B.x-A.x, B.y-A.y);
        Vecteur AC=new Vecteur(C.x-A.x, C.y-A.y);
        double numerateur=u.x*AC.y-u.y*AC.x;
        if (numerateur<0)
        {
            numerateur=-numerateur;
        }
        double denominateur=Math.sqrt(u.x*u.x+u.y*u.y);
        double cl=numerateur/denominateur;
        return cl<C.r;
    }

    public final boolean collision(Segment s) //vérifié
    {
        if (!collision((Droite)s))
        {
            return false;
        }

        Point A=s.a;
        Point B=s.b;
        Cercle C=this;

        Vecteur AB=new Vecteur(B.x-A.x, B.y-A.y);
        Vecteur AC=new Vecteur(C.x-A.x, C.y-A.y);
        Vecteur BC=new Vecteur(C.x-B.x, C.y-B.y);
        double pscal1=AB.x*AC.x+AB.y*AC.y;
        double pscal2=(-AB.x)*BC.x+(-AB.y)*BC.y;
        if (pscal1>=0&&pscal2>=0)
        {
            return true;
        }
        if (collision(A))
        {
            return true;
        }
        if (collision(B))
        {
            return true;
        }
        return false;
    }
    
    public final Vecteur rebondir(Segment segment, Vecteur direction)
    {
        if (collision(segment))
        {
            Vecteur normale=segment.normale(p); //p doit être le point d'intersection
            direction=direction.rebond(normale);
        }
        return direction;
    }

   public final Vecteur rebondir(Rectangle rectangle, Vecteur direction)
    {
        Vecteur dir;
        dir=rebondir(rectangle.getNord(), direction);
        if (dir!=direction)
        {
            return dir;
        }
        dir=rebondir(rectangle.getSud(), direction);
        if (dir!=direction)
        {
            return dir;
        }
        dir=rebondir(rectangle.getOuest(), direction);
        if (dir!=direction)
        {
            return dir;
        }
        dir=rebondir(rectangle.getEst(), direction);
        if (dir!=direction)
        {
            return dir;
        }
        return direction;
    }

     private Point intersection(Cercle c) // /!\ Ne considère qu'une seule intersection, peut bugger
     {
         double x=c.r*p.x+c.p.x*r;
         double y=c.r*p.y+c.p.y*r;
         double denom=r+c.r;
         return new Point(x/denom, y/denom);
     }

    public final Vecteur rebondir(Cercle cercle, Vecteur direction) /!\ N'importe quoi...
    {
        if (collision(cercle))
        {
            Point intersection=intersection(cercle);
            Segment rayon=new Segment(p, intersection);
            Point p1=rayon.perpendiculaire(intersection, x-r);
            Point p2=rayon.perpendiculaire(intersection, x+r);
            Vecteur normale=new Segment(p1, p2).normale(p);
            direction=direction.rebond(normale);
        }
        return direction;
        //return rebondir(cercle.getRectangle(), direction);
    }
}

package collisions;

public class Polygone
{
    final Point[] points;

    public Polygone(Point[] points)
    {
        this.points=points;
    }

    public final Point[] points()
    {
        return points;
    }

    public final boolean collision_convexe(Point p)
    {
        Point P=p;

        double ld=0;
        for (int i=0; i<points.length; ++i)
        {
            Point A=points[i];
            Point B=i==points.length-1?points[0]:points[i+1];
            Vecteur D=new Vecteur(B.x-A.x, B.y-A.y);
            Vecteur T=new Vecteur(P.x-A.x, P.y-A.y);
            double d=D.x*T.y-D.y*T.x;
            if ((d>0 && ld<0) || (d<0 && ld>0))
            {
                return false;
            }
            ld=d;
        }
        return true;
    }

    public final boolean collision(Point p)
    {
        Point P=p;
        Point I=new Point(100000+Math.random()*1000, 100000+Math.random()*1000);
        int intersections=0;
        for (int i=0; i<points.length; ++i)
        {
            Point A=points[i];
            Point B=i==points.length-1?points[0]:points[i+1];
            int iseg=intersectionSegment(A, B, I, P);
            if (iseg==-1)
                return collision(P);
            intersections+=iseg;
        }
        return intersections%2==1;
    }

    private static int intersectionSegment(Point A, Point B, Point I, Point P)
    {
        Vecteur D=new Vecteur(B.x-A.x, B.y-A.y);
        Vecteur E=new Vecteur(P.x-I.x, P.y-I.y);
        double denom=D.x*E.y-D.y*E.x;
        if (denom==0)
            return -1;
        double t=-(A.x*E.y-I.x*E.y-E.x*A.y+E.x*I.y)/denom;
        if (t<0 || t>=1)
            return 0;
        double u=-(-D.x*A.y+D.x*I.y+D.y*A.x-D.y*I.x)/denom;
        if (u<0 || u>=1)
            return 0;
        return 1;
    }
}

package collisions;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public abstract class Terrain implements Iterable<ObjetCollision>
{
    private final List<ObjetCollision> terrain;
    
    public Terrain()
    {
        terrain=new ArrayList<ObjetCollision>();
    }

    public final Iterator<ObjetCollision> iterator()
    {
        return terrain.iterator();
    }
    
    public final List<ObjetCollision> getTerrain()
    {
        return terrain;
    }
}

package collisions;

public final class TerrainRectangle extends Terrain
{
    private final int width;
    private final int height;
    private final Rectangle limites;
    
    public TerrainRectangle(int width, int height)
    {
        super();
        this.width=width;
        this.height=height;
        limites=new Rectangle(0, 0, width, height);
    }
    
    public final int getWidth()
    {
        return width;
    }
    
    public final int getHeight()
    {
        return height;
    }
        
    public final Rectangle getLimites()
    {
        return limites;
    }
}

J'ai évidemment réalisé des tests sur les collisions donc voilà le code:

PACKAGE tests

package tests;

import collisions.Cercle;
import collisions.Droite;
import collisions.Point;
import collisions.Polygone;
import collisions.Rectangle;
import collisions.Segment;
import collisions.Vecteur;

public class Main
{
    public static void main(String[] args)
    {
        rectangle();
        cercle();
        vecteur();
        polygone();
        droite();
        segment();
    }

    private static void rectangle()
    {
        Rectangle rectangle=new Rectangle(new Point(400, 300), 100, 200);
        //Point
        assertTrue(rectangle.collision(new Point(403, 305))); //dedans
        assertFalse(rectangle.collision(new Point(394, 384))); //dehors
        //Rectangle
        assertTrue(rectangle.collision(new Rectangle(new Point(425, 325), 50, 25))); //dedans
        assertFalse(rectangle.collision(new Rectangle(new Point(300, 400), 50, 25))); //dehors
        assertTrue(rectangle.collision(new Rectangle(new Point(450, 450), 100, 100))); //intersection
    }

    private static void cercle()
    {
        Cercle cercle=new Cercle(new Point(400, 300), 200);
        //Point
        assertTrue(cercle.collision(new Point(258, 165))); //dedans
        assertFalse(cercle.collision(new Point(232, 179))); //dehors
        //Cercle
        assertTrue(cercle.collision(new Cercle(new Point(300, 400), 50))); //dedans
        assertFalse(cercle.collision(new Cercle(new Point(100, 100), 50))); //dehors
        assertTrue(cercle.collision(new Cercle(new Point(200, 200), 100))); //intersection
        //Droite
        assertTrue(cercle.collision(new Droite(new Point(0, 0), new Point(100, 100)))); //le segment n'est pas dedans mais la droite oui
        assertFalse(cercle.collision(new Droite(new Point(0, 0), new Point(269, 558)))); //la droite est dehors
        assertTrue(cercle.collision(new Droite(new Point(0, 0), new Point(260, 167)))); //la droite est dedans
        //Segment
        assertFalse(cercle.collision(new Segment(new Point(0, 0), new Point(100, 100)))); //le segment n'est pas dedans
        assertFalse(cercle.collision(new Segment(new Point(0, 0), new Point(269, 558)))); //la segment est dehors
        assertTrue(cercle.collision(new Segment(new Point(0, 0), new Point(260, 167)))); //la segment est dedans
        //Segment (bis)
        cercle=new Cercle(new Point(108, 508), 50);
        assertFalse(cercle.collision(new Segment(new Point(0, 600), new Point(800, 600)))); //ne touche pas
        //Intersection
        System.out.println("{200;100} : "+new Cercle(new Point(100, 100), 100).intersection(new Cercle(new Point(300, 100), 100)));
        //System.out.println("{29;29} : "+new Cercle(new Point(100, 100), 100).intersection(new Droite(new Point(0, 0), new Point(100, 100)))[0]);
    }

    private static void vecteur()
    {
        Droite droite=new Droite(new Point(0, 146), new Point(599, 438));
        Vecteur normale=droite.normale(new Point(280, 280));
        Vecteur rebond=new Vecteur(280, 280).rebond(normale);
        System.out.println(rebond);
    }

    private static void polygone()
    {
        Polygone pentagone=new Polygone(new Point[]
                {
                    new Point(300, 100), new Point(110, 238), new Point(182, 462), new Point(418, 462), new Point(490, 238)
                });
        //Point
        assertTrue(pentagone.collision_convexe(new Point(297, 110))); //dedans
        assertFalse(pentagone.collision_convexe(new Point(197, 160))); //dehors
        assertTrue(pentagone.collision(new Point(297, 110))); //dedans
        assertFalse(pentagone.collision(new Point(197, 160))); //dehors

        Polygone non_convexe=new Polygone(new Point[]
                {
                    new Point(300, 300), new Point(110, 238), new Point(182, 462), new Point(418, 462), new Point(490, 238)
                });
        //Point
        System.out.println("N-C avec C "+non_convexe.collision_convexe(new Point(287, 302))); //dedans
        System.out.println("N-C avec C "+non_convexe.collision_convexe(new Point(299, 295))); //dehors
        assertTrue(non_convexe.collision(new Point(287, 302))); //dedans
        assertFalse(non_convexe.collision(new Point(299, 295))); //dehors
    }

    private static void droite()
    {
        Droite droite=new Droite(new Point(0, 146), new Point(599, 438));
        System.out.println(droite.projection(new Point(100, 100)));
        System.out.println(droite.projection(new Point(18, 542)));
        System.out.println(droite.normale(new Point(100, 100)));
        System.out.println(droite.normale(new Point(18, 542)));

        droite=new Droite(new Point(50, 200), new Point(200, 50));
        System.out.println(droite.projection(new Point(100, 100)));
        System.out.println(droite.projection(new Point(18, 542)));
        System.out.println(droite.normale(new Point(100, 100)));
        System.out.println(droite.normale(new Point(18, 542)));
    }

    private static void segment()
    {
        Segment segment=new Segment(new Point(200, 200), new Point(400, 400));
        //droite
        assertTrue(segment.collision(new Droite(new Point(200, 400), new Point(400, 200)))); //coïncide
        assertTrue(segment.collision(new Droite(new Point(200, 400), new Point(299, 301)))); //le segment ne coïncide pas mais la droite oui
        assertTrue(segment.collision(new Droite(new Point(200, 400), new Point(300, 300)))); //pile dessus
        assertFalse(segment.collision(new Droite(new Point(200, 400), new Point(500, 500)))); //ne le traverse pas
        //segment
        assertTrue(segment.collision(new Segment(new Point(200, 400), new Point(400, 200)))); //coïncide
        assertFalse(segment.collision(new Segment(new Point(200, 400), new Point(299, 301)))); //ne coïncide pas
        assertTrue(segment.collision(new Segment(new Point(200, 400), new Point(300, 300)))); //pile dessus
        assertFalse(segment.collision(new Segment(new Point(200, 400), new Point(500, 500)))); //ne le traverse pas
    }

    private static void assertTrue(boolean b)
    {
        System.out.println(b?"OK.":"FAIL.");
    }

    private static void assertFalse(boolean b)
    {
        assertTrue(!b);
    }
}

J'ai également réalisé des classes gérant le moteur GUI mais je dois corriger les soucis du moteur avant de vous exposer le GUI.

Ce qui pose problème, ce sont les fonctions de rebond (principalement celles que j'ai surlignées en rouge)... je fais des rebonds en utilisant des formules dont je n'ai aucune connaissance... Ce qui fait que ça rebondit n'importe comment.

Si vous pouviez m'aider, ce serait sympa.

Amicalement,

Aenonis

[invited1c1a33e]

Bonsoir, j'ai regardé le programme superficiellement, mais je n'ai pas vu la masse des boules dedans. C'est plus un problème de physique qu'informatique à mon avis:

http://fr.wikipedia.org/wiki/Choc_%C3%A9lastique

[invite1bcc2991]

Merci, je vais y jeter un oeil et je reviens vers toi quand je me suis penché sur la question.

Merci

[A voir en vidéo sur Futura]

[invite1bcc2991]

Ok.

J'ai regardé le lien wiki que tu m'as passé.

En effet, on a bien la collision de deux boules, et vu que la masse est identique pour tous les objets présents, il est inutile de la préciser.

Mieux encore, j'ai implémenté plusieurs classes qui identifient chaque objet présent dans le plan de l'application:
- Le point
- Le rectangle (movable)
- Le cercle (movable)
- Le polygone
- La droite
- Le segment

Le but, c'est de faire déplacer les éléments estampillés "movable" et de les faire rebondir sur les autres éléments présents dans le plan.
De ce fait, il faudrait implémenter des fonctions rebondir dans les classes "movables" sur tous les autres élements (y compris les classes movables).
Mais un élément movable peut être placé de façon statique dans le plan.

Et c'est là que ça se complique vu que je suis archinul en physique.

Voilà,

Merci d'avance.

Aenonis

[invite1bcc2991]

Petite modification:

En effet, les objets susmentionnés existent dans l'application.
Mais seuls trois (ou quatre) d'entre eux peuvent être utilisés dans le plan, je cite:
- Le cercle (movable)
- Le rectangle (movable)
- Le segment (non-movable)
(- Le polygone) => on pourrait mettre un polygone quelconque dans le plan mais ça risque de compliquer le bazar, surtout si on décide qu'il soit movable.

De plus, le plan est un Rectangle (classe) et les éléments sont DEDANS, or une collision se fait lorsqu'on est DEHORS, ce qui complique les choses...

Merci,

Aenonis

[invited1c1a33e]

Bonjour, c'est un problème d'analyse, movable -> mouvement, pour les collisions il faut autre chose car comme vous l'avez remarqué une balle peut rebondir sur le bord qui lui ne bougera pas.

[invite1bcc2991]

Re.

Je vous ai mis en pièce jointe le projet (les src + le jar) dans un dossier compressé.

Les sources pour que vous voyez le code déjà réalisé.

Vous pouvez exécuter le JAR afin de voir les bizarreries que j'ai, en effet, j'ai plusieurs soucis:
- la boule, lorsqu'elle cogne le coté droit et le coté du bas, elle sort un peu du terrain puis rebondit.
- lorsqu'elle cogne deux cotés à la fois (dans un angle), la boule reste collée à un des cotés et lorsqu'elle rebondit sur un autre coté, elle se décolle, enfin, vous verrez ça à l'exécution.

NB: décompressez le zip avec d'éxécuter le JAR, en effet, elle dépend de deux JAR placés dans le dossier lib.

Au plaisir,

Merci.

Aenonis

[invited1c1a33e]

Désolé mais je ne vais pas regarder ce zip. Vous avez un problème d'analyse le code n'a aucun intérêt à ce stade du développement. J'essayais de vous faire comprendre que vous avez besoin d'une autre interface que movable...

[invite1bcc2991]

Oki.

Qu'avez-vous à me proposer comme autre interface?

Je ne suis pas fort en analyse, si vous pouviez me mettre sur la voie, ce serait bien.

Au plaisir,

Aenonis

[invited1c1a33e]

Et bien votre problème c'est que vous avez une boule qui se déplace et rebondit après une collision.

Donc vous avez deux interfaces : déplaçable (movable) et rebondissable (collidable en anglais). Les bords ne se déplacent pas mais sont clairement rebondissables, car on peut rebondir dessus.

Par conséquent votre choc fait interagir un objet déplaçable et un objet rebondissable.

C'est mieux quand une interface fait précisément ce que son nom indique, bien que dans la littérature on voit que ce n'est pas toujours évident.

Dans votre cas vous pourriez faire hériter déplaçable de rebondissable, ou les séparer complètement. Ce qui compte c'est que vous utilisiez la bonne formule quand la boule rencontre le mur.

C'est un problème de symétrie du niveau 6ème.

[invited1c1a33e]

Sinon vous rendez les murs déplaçables en leur assignant une masse (par exemple 400 kg et 10g pour les boules). Auquel cas vous n'avez plus qu'une interface à gérer.

[invite1bcc2991]

Dans votre cas vous pourriez faire hériter déplaçable de rebondissable, ou les séparer complètement.

Alors, je te remercie énormément de cet éclaircissement.

Mais j'avais déjà effectué cette modification dans le code que j'ai linké dans le ZIP.

Le code linké en premier post n'est que souvenir, j'ai beaucoup travaillé dessus pour le rendre propre.

C'est pour ça que je ne comprenais pas pourquoi vous me disiez que j'avais un soucis d'analyse vu que j'avais déjà modifié la hiérarchie des classes.

Ce qui compte c'est que vous utilisiez la bonne formule quand la boule rencontre le mur.

En fait, c'est tout con, le seul truc que j'ai besoin, c'est la formule...

J'utilise une formule dont je n'ai aucune connaissance.

J'ai fait un copier-coller du cours du site du Zéro.
Si vous regardez cette page, ils parlent du rebond, de la normale et de la projection.

Mais lorsque je fais la projection du centre du cercle sur le segment et que je prends la normale sur ce point, j'obtiens un vecteur indéfini (NaN;NaN), ce qui pose problème.

En vous remerciant,

Aenonis

[invited1c1a33e]

Pour la formule exacte il faudrait demander dans la section mathématiques du colège et du lycée, c'est un problème de sixième :

http://www.lapasserelle.com/cours-en...ies/index.html