Calculer l?intersection de deux point. [Résolu]

Signaler
Messages postés
24
Date d'inscription
vendredi 20 janvier 2006
Statut
Membre
Dernière intervention
5 mai 2009
-
 Utilisateur anonyme -
Salut tout le monde


Je suis un débutant en java


Je suis en cours de développer un jeu


Je veux savoir commet calculer l’intersection de deux point.


Le principe de ce jeu c’est je tire une balle qui prend un
chemin d’un arc ce que je jeux c’est lorsqu’il choque un meure il doit arrêter.


Je ne sais pas comment.


Merci

11 réponses

Messages postés
24
Date d'inscription
vendredi 20 janvier 2006
Statut
Membre
Dernière intervention
5 mai 2009

cette methode est trop long.

mais la solution c'est de calculer l'intervalle où  xa<x<xa+L et ya<y<ya+H

merci mes amis
Messages postés
212
Date d'inscription
dimanche 3 avril 2005
Statut
Membre
Dernière intervention
28 mai 2011
1
Ca veut dire quoi intersection de deux point ? Deux points peuvent coinsider mais pas s'intersecter.

___________________
Hebergement gratuit
Messages postés
24
Date d'inscription
vendredi 20 janvier 2006
Statut
Membre
Dernière intervention
5 mai 2009

oui ça ce que je veux
Messages postés
161
Date d'inscription
mardi 26 avril 2005
Statut
Membre
Dernière intervention
6 novembre 2008
4
slt,
compare les coordonnes:
A=B si et seulement si Xa=Xb et Ya=Yb
c'est facile ;-)
Messages postés
24
Date d'inscription
vendredi 20 janvier 2006
Statut
Membre
Dernière intervention
5 mai 2009

Merci pour la réponse
je vais tester puis je vais vous répondre
Messages postés
212
Date d'inscription
dimanche 3 avril 2005
Statut
Membre
Dernière intervention
28 mai 2011
1
Si tu veux connaitre si deux points coincident tu compare juste les coordonées mais seulement si tu fais des calculs avec des entiers mais si tu fais les calculs en flotants il est plus correct de verifier que la distance entre les 2 points est inferieure à une certaine valeur choisie à l'avance donc il faut verifier que
(Xa-Xb)^2 + (Ya-Yb)^2 < D^2

___________________
Hebergement gratuit

Tu parles d'un mur, donc je ne pense pas que ce qu'on t'a proposé va suffire. J'ai un bout de code qui marche très bien pour des murs orthogonaux pour vérifier si un projectile quelconque passe à travers un mur (code source sous licence GPL version 2, extrait du First Person Shooter TUER) :

/**
     * compute an impact from the bounds of a tarjectory
     * in the simplified case (i.e with orthogonal walls and
     * in the planar surface Oxz)
     * @param x1: abscissa of the previous position of the projected object
     * @param z1: applicate of the previous position of the projected object
     * @param x2: abscissa of the next position of the projected object
     * @param z2: applicate of the next position of the projected object
     * @param wx1: abscissa of the first point of the wall
     * @param wz1: applicate of the first point of the wall
     * @param wx2: abscissa of the second point of the wall
     * @param wz2: applicate of the second point of the wall
     * @param wnx: abscissa of the normal at the impact
     * @param wnz: applicate of the normal at the impact
     * @return the computed impact if found, otherwise null
     */
    public static final Impact computeImpactFromTargetoryBipoint(float x1,float z1,
            float x2,float z2,float wx1,float wz1,float wx2,float wz2,float wnx,
            float wnz){
        boolean isHorizontal=(wnz!=0);
        if(x1==x2)
            {if(!isHorizontal)
                {if(x1==wx1)
                    {if(wz1>wz2)
                         {if(wz2<=z2 && z2<=wz1)
                              {if(z1>z2)
                                   return(new Impact(wx1,0.0f,wz1,wnx,0,wnz));
                               else
                                   return(new Impact(wx1,0.0f,wz2,wnx,0,wnz));
                              }
                          else                             
                              return(null);
                         }
                     else
                         {if(wz1<=z2 && z2<=wz2)
                              {if(z1>z2)
                                   return(new Impact(wx1,0.0f,wz2,wnx,0,wnz));
                               else
                                   return(new Impact(wx1,0.0f,wz1,wnx,0,wnz));                               
                              }
                          else
                              return(null);                        
                         }
                     }
                 else                  
                     return(null);                   
                }
             else
                 {if(wx1>wx2)
                      {if(wx2<=x1 && x1<=wx1)
                           {if(z1>z2)
                                {if(z2<=wz1 && wz1<=z1)
                                     return(new Impact(x1,0.0f,wz1,wnx,0,wnz));
                                 else                                   
                                     return(null);
                                }
                            else
                                {if(z1<=wz1 && wz1<=z2)
                                     return(new Impact(x1,0.0f,wz1,wnx,0,wnz));
                                 else                                   
                                     return(null);
                                }
                           }
                       else                         
                           return(null);
                      }
                  else
                      {if(wx1<=x1 && x1<=wx2)
                           {if(z1>z2)
                                {if(z2<=wz1 && wz1<=z1)
                                     return(new Impact(x1,0.0f,wz1,wnx,0,wnz));
                                 else                                   
                                     return(null);
                                }
                            else
                                {if(z1<=wz1 && wz1<=z2)
                                     return(new Impact(x1,0.0f,wz1,wnx,0,wnz));
                                 else                                   
                                     return(null);
                                }                            
                           }
                       else
                           return(null);
                      }
                 }
            }
        else
            {float a=(z2-z1)/(x2-x1);
             float b=z1-(a*x1);
             float impx,impz;
             if(!isHorizontal)
                 {impx=wx1;
                  impz=(a*impx)+b;
                  if(wz1>wz2)
                      {if(wz2<=impz && impz<=wz1)
                           return(new Impact(impx,0.0f,impz,wnx,0,wnz));
                       else                        
                           return(null);
                      }
                  else
                      {if(wz1<=impz && impz<=wz2)
                           return(new Impact(impx,0.0f,impz,wnx,0,wnz));
                       else                       
                           return(null);
                      }
                 }
             else
                 {if(a!=0)
                      {impz=wz1;
                       impx=(impz-b)/a;
                       if(wx1>wx2)
                           {if(wx2<=impx && impx<=wx1)
                                return(new Impact(impx,0.0f,impz,wnx,0,wnz));
                            else                             
                                return(null);
                           }
                       else
                           {if(wx1<=impx && impx<=wx2)
                                return(new Impact(impx,0.0f,impz,wnx,0,wnz));
                            else                              
                                return(null);
                           }
                      }
                  else
                      {if(z1==wz1)
                           {if(wx1>wx2)
                               {if(wx2<=x2 && x2<=wx1)
                                    {if(x1>x2)
                                         return(new Impact(wx1,0.0f,wz1,wnx,0,wnz));
                                     else
                                         return(new Impact(wx2,0.0f,wz1,wnx,0,wnz));
                                    }
                                else
                                    return(null);
                               }
                           else
                               {if(wx1<=x2 && x2<=wx2)
                                    {if(x1>x2)
                                         return(new Impact(wx2,0.0f,wz1,wnx,0,wnz));
                                     else
                                         return(new Impact(wx1,0.0f,wz1,wnx,0,wnz));                               
                                    }
                                else
                                    return(null);
                               }
                           }
                       else
                           return(null);                     
                      }
                 }
            }     
    }


Ma méthode marche, elle est éprouvée. Si tu te réduis à un cas encore plus simple, alors en effet, tu peux trouver un procédé de calcul plus simple. Tu ne dis pas ce qu'est xa, x, L, ya, y et H donc ça ne sert pas à grand chose.


Je viens de comprendre ce que tu as voulu écrire. La méthode que tu donnes ne marche que si tu es sûr que le point que tu testes se trouve au moins sur la droite à laquelle le mur appartient (si le mur a une épaisseur quasi nulle) ou bien si le point que tu testes est un bon candidat sur ta trajectoire. Quand tu tires, ton projectile prend une certaine trajectoire et tu choisis de faire le test sur un nombre fini de valeurs faisant partie de cette trajectoire. Si la distance entre les valeurs appartenant à la trajectoire que tu choisis de tester est supérieure à racine(L²+H²), alors ta méthode te dira que ton projectile ne traverse jamais le mur même quand elle le traverse vraiment.

Par conséquent, arrange toi pour que cette distance soit au moins inférieure à racine(L²+H²) (tu prends des risques dès que cette distance est supérieure soit à L soit à H) et ta méthode marchera sinon je te conseille vivement d'utiliser ma méthode.

Enfin, évite les fautes d'orthographe.

Messages postés
24
Date d'inscription
vendredi 20 janvier 2006
Statut
Membre
Dernière intervention
5 mai 2009

Merci
Pour L c'est la largeur du mur.
Pour H c'est la hauteur du Mur.
donc pour calculer la coincidence d'un point avec le mur,il faut que ce point vérifier la relation suivantes:
    xm<x<xm+L et ym<y<ym+H

note:
point(x,y);
mur(xm,ym,L,H);

Ok c'est ce que je pensais et je t'ai dit dans quel cas ça ne suffira pas.