Java: détection de détection détectant incorrectement le chevauchement entre deux objets

Question

donc j'ai un jeu d'aviron dans lequel un objet de bateau doit esquiver les obstacles objets placés au hasard en utilisant les touches fléchées. Si le bateau heurte l'un des obstacles, le bateau subit des dégâts aléatoires. Le bateau est une image 27x52 (avec 2 pixels de rien de chaque côté de sorte que le code montre 2-25) et les obstacles sont des rectangles.

J'ai la détection de coup qui fonctionne pour la plupart; Cependant, chaque fois que le bateau est sur le côté droit d'un rectangle plus large que large, il subira des dégâts, même si le bateau se trouve à environ 5-10 pixels du bord droit du rectangle. Reportez-vous à cette image pour une meilleure compréhension du problème: http://imgur.com/pqDLMrl

Dans mon code, je crée un tableau de 15 obstacles. Les obstacles prennent les paramètres (couleur de couleur, dommageDealt, int xPos, int yPos, largeur int, hauteur int, booléen hasHit).

//Create array of obstacles 
for(int x = 0; x < 15; x++) { 
     obstacles[x] = new Obstacle((new Color(rand.nextInt(81), rand.nextInt(51), rand.nextInt(51))), rand.nextInt(21) + 10, rand.nextInt(601), 
      (-x * (rand.nextInt(51) + 31)), (rand.nextInt(31) + 5), (rand.nextInt(31) + 5), false); 
    } 

Voici le code de détection de succès (Ceci est un pour le cyclisme en boucle à travers le réseau d'objets d'obstacles:

for(int y = 2; y <= 25; y++) { 
       //Obstacles hit detection 
       for(int z = 0; z <= obstacles[x].getw(); z++) {   
         if(boat.getx() + y == obstacles[x].getx() + z && boat.gety() == obstacles[x].gety()) { 
          if(!obstacles[x].getDamaged()) { 
           boat.setHealth(boat.getHealth() - obstacles[x].getdmg()); 
           obstacles[x].setDamaged(true); 
          } 
         }    
       } 

En ce moment, il fait défiler les valeurs x du bateau, 2 à 25, au lieu de 0 à 27 à cause des deux pixels de rien de chaque côté, puis il fait défiler les valeurs de x de l'obstacle (xPos à xPos + largeur) et voit si l'une de ces valeurs correspond.S'il y a une correspondance, et les valeurs y Dans ce cas, le bateau subira des dégâts, ce qui ne se produit que lorsque le bateau se trouve sur le côté droit d'un obstacle et que l'obstacle est plus grand que large. Cependant, je ne peux pas trouver une solution à mon erreur. Merci.

EDIT: Voici le code pour les classes de bateaux et d'obstacles.

import java.awt.Color; 
import java.awt.Rectangle; 

public class Obstacle { 
    private int dmg, xPos, yPos, height, width; 
    private Color color; 
    private boolean hasDamaged; 

    public Obstacle(Color hue, int damage, int x, int y, int w, int h, boolean damaged) { 
     dmg = damage; 
     xPos = x; 
     yPos = y; 
     width = w; 
     height = h; 
     color = hue; 
     hasDamaged = damaged; 
    } 

    public boolean getDamaged() { 
     return hasDamaged; 
    } 
    public void setDamaged(boolean damaged) { 
     hasDamaged = damaged; 
    } 

    public Color getColor() { 
     return color; 
    } 

    public int getdmg() { 
     return dmg; 
    } 
    public void setdmg(int damage) { 
     dmg = damage; 
    } 

    public int getx() { 
     return xPos; 
    } 
    public void setx(int x) { 
     xPos = x; 
    } 

    public int gety() { 
     return yPos; 
    } 
    public void sety(int y) { 
     yPos = y; 
    } 

    public int getw() { 
     return width; 
    } 
    public void setw(int w) { 
     width = w; 
    } 

    public int geth() { 
     return height; 
    } 
    public void seth(int h) { 
     height = h; 
    } 

    public Rectangle getBounds() { 
     return new Rectangle(xPos, yPos, width, height); 
    } 
} 

Et la classe bateau:

import java.awt.Image; 
import java.awt.image.BufferedImage; 
import java.awt.Rectangle; 

public class Boat { 

private int hp, xPos, yPos, dx; 
private BufferedImage boatPic; 

public Boat(BufferedImage img, int health, int x, int y, int velX) { 
    boatPic = img; 
    hp = health; 
    xPos = x; 
    yPos = y; 
    dx = velX; 
} 


public BufferedImage getImage() { 
    return boatPic; 
} 
public void setImage(BufferedImage img) { 
    boatPic = img; 
} 

public int getHealth() { 
    return hp; 
} 
public void setHealth(int health) { 
    hp = health; 
} 

public int getx() { 
    return xPos; 
} 
public void setx(int x) { 
    xPos = x; 
} 

public int gety() { 
    return yPos; 
} 
public void sety(int y) { 
    yPos = y; 
} 

public int getdx() { 
    return dx; 
} 
public void setdx(int velX) { 
    dx = velX; 
} 

public Rectangle getBounds() { 
    return new Rectangle(xPos, yPos, 25, 49); 
}  
} 

Answer 1

Si votre vaisseau face alway la même direction, vous pouvez vérifier la collision beaucoup plus facile.

En créant une méthode pour votre vaisseau et pour les obstacles qui renvoie un rectangle avec la taille de votre objet.

public Rectangle getBounds() { 
    return new Rectangle(shipPosX, shipPosY, widht, height); 
} 

Comme ceci. De cette façon, vous pouvez tester la collision sur une ligne:

getBounds().intersects(obstacle.getBounds()); 

Cela retournera vrai si elles se croisent. Si vous voulez être plus précis, ou voulez des cas différents pour des collisions de différentes directions, vous pouvez créer un rectangle pour différentes parties de votre vaisseau, comme son corps et ses ailes.

public Rectangle getRightWingBound(){} 
public Rectangle getLeftWindBound(){} 

et ainsi de suite.