Aide avec méthode simple, Java

Question

Ceci est vraiment une question stupide, mais j'ai les yeux fixés sur ce problème depuis trop longtemps et je ne peux pas figure ce que le problème est:

/** 
    * public boolean overlap(int targetX, int targetY) { 
    * Returns true if the target position is sufficient close to this ghost 
    * If target position is 16 pixels or less in the x direction 
    * and similarly in y direction, return true. Otherwise return false 
    * 
    * @param targetX 
    * @param targetY 
    * @return 
    */ 
    public boolean overlap(int targetX, int targetY){ 
     double x=this.getX(); 
     double y=this.getY(); 
     double deltaX=targetX-x; 
     double deltaY=targetY-y; 
     if(deltaX<=16 && deltaX>=0 && deltaY<=16 && deltaY>=0) 
      return true; 
     else 
      return false;  
    } 

Cela devrait fonctionner droite? Mais ça ne marche pas. Si je cours ce test, il échoue le assertTrue. (g1.x = 100 et g1.y = 1000)

double theta = 2 * Math.PI * Math.random(); 
    int x = 100 + (int) (16 * Math.cos(theta)); 
    int y = 1000 + (int) (16 * Math.sin(theta)); 
    assertTrue(g1.overlap(x, y)); 

Est-ce que quelqu'un voit quelque chose que je ne sais pas?

Answer 1

Basé sur le javadoc de la méthode overlap, vous devez prendre la valeur absolue de targetX-x et targetY-y, et retourne vrai si les deux d'entre eux sont inférieures ou égales à 16

Il ressemblerait à ceci:

public boolean overlap(int targetX, int targetY){ 
    double x=this.getX(); 
    double y=this.getY(); 
    double deltaX = Math.abs(targetX-x); 
    double deltaY = Math.abs(targetY-y); 

    return (deltaX<=16 && deltaY<=16);  
} 

Answer 2

Vous retournerez true si deltaX et deltaY sont chacun entre 0 et 16. Mais sin() et cos() ne sont pas garantis retourner des nombres positifs.

Answer 3

On dirait deltaX et deltaY sera négatif à la moitié du temps, et donc votre test échouera environ 3/4 du temps.

Answer 4

Si vous voulez la distance indépendamment de la direction ne devrait pas vous avez:

deltaX = Math.abs(targetX-x); 
deltaY = Math.abs(targetY-y); 

Si votre cible est à 16px mais à gauche ou au-dessus, vous obtiendrez une valeur delta négative et la méthode retournerait faux .