problème avec l'extension des classes

Question

Je fais Braid. J'ai une classe Wall qui empêche qu'un objet entre dans un mur. Tout avec Wall fonctionne. Mais maintenant j'essaie de faire la même chose avec les plafonds. Ma classe de plafond s'étend Wall. J'ai simplement fait un constructeur comme celui-ci:

public Ceiling(boolean deadly, int[] xPositions, int[] yPositions) 
{ 
    super(deadly, 
    Direction.Down, //Enum: the direction you have to leave the wall (Left, Right) 
        //Here of course down 
    xPositions, yPositions); 
} 

Maintenant, j'ai dans mon niveau de classe un ArrayList de tous les murs et une ArrayList de tous les plafonds. Je dois ajouter les murs de cette façon:

walls.add(new Wall(false, Direction.Right, ..., ...)); 

et les plafonds de cette façon:

ceilings.add(new Ceiling(false, ..., ...)); 

Le ... remplace les coordonnées.

Si je vérifie s'il y a un objet dans un plafond: il ne s'est rien passé: l'objet traverse le plafond. Et si j'utilise cette façon d'ajouter un plafond, cela fonctionne:

ceilings.add(new Wall(false, Direction.Down, ..., ...)); 

J'espère avoir bien expliqué. Est-ce que quelqu'un sait quel est le problème?

Merci

Edit:

Ceci est mon code collition:

public boolean intersects(Rectangle r) 
{ 
    if (!bounds.intersects(r)) 
    { 
     return false; 
    } 
    for (int i = 1; i < yPositions.length; i++) { 
     Line l = new Line(xPositions[i - 1], yPositions[i - 1], xPositions[i], yPositions[i]); 
     if (r.intersectsLine(l)) { 
      return true; 
     } 
    } 
    return false; 
} 

Mon code

---

' doodelijk' signifie mortel

mur:

package levels; 

import domein.Direction; 
import java.awt.Point; 
import java.awt.Rectangle; 
import java.awt.geom.Line2D; 
import java.awt.geom.Point2D; 
import java.awt.geom.Rectangle2D; 

public class Wall 
{ 

    public boolean doodelijk; 
    public int[] yPositions; 
    public int[] xPositions; 
    private Rectangle bounds; 
    public Direction directionToLeave; 

    public Wall(boolean doodelijk, Direction directionToLeave, int[] yPositions, int[] xPositions) 
    { 
     this.doodelijk = doodelijk; 
     this.yPositions = yPositions; 
     this.xPositions = xPositions; 
     this.directionToLeave = directionToLeave; 
     createRectangle(); 
    } 

    public boolean intersects(Rectangle r) 
    { 
     if (!bounds.intersects(r)) 
     { 
      return false; 
     } 
     for (int i = 1; i < yPositions.length; i++) { 
      Line l = new Line(xPositions[i - 1], yPositions[i - 1], xPositions[i], yPositions[i]); 
      if (r.intersectsLine(l)) { 
       return true; 
      } 
     } 
     return false; 
    } 

    private void createRectangle() 
    { 
     int x = Integer.MAX_VALUE; 
     int y = Integer.MAX_VALUE; 
     int x1 = 0; 
     int y1 = 0; 
     for (int i = 0; i < xPositions.length; i++) 
     { 
      int tx = xPositions[i]; 
      int ty = yPositions[i]; 
      if (x > tx) 
      { 
       x = tx; 
      } 
      if (y > ty) 
      { 
       y = ty; 
      } 
      if (x1 < tx) 
      { 
       x1 = tx; 
      } 
      if (y1 < ty) 
      { 
       y1 = ty; 
      } 
     } 
     bounds = new Rectangle(x, y, x1 - x + 1, y1 - y +1); 
     System.out.println("Rect: " + bounds); 
    } 

    class Line extends Line2D 
    { 

     Point2D p1; 
     Point2D p2; 

     public Line() 
     { 
      p1 = new Point(); 
      p2 = new Point(); 
     } 

     public Line(Point2D p1, Point2D p2) 
     { 
      this.p1 = p1; 
      this.p2 = p2; 
     } 

     public Line(double X1, double Y1, double X2, double Y2) 
     { 
      this(); 
      setLine(X1, Y1, X2, Y2); 
     } 

     @Override 
     public double getX1() 
     { 
      return p1.getX(); 
     } 

     @Override 
     public double getY1() 
     { 
      return p1.getY(); 
     } 

     @Override 
     public Point2D getP1() 
     { 
      return p1; 
     } 

     @Override 
     public double getX2() 
     { 
      return p2.getX(); 
     } 

     @Override 
     public double getY2() 
     { 
      return p2.getY(); 
     } 

     @Override 
     public Point2D getP2() 
     { 
      return p2; 
     } 

     @Override 
     public void setLine(double X1, double Y1, double X2, double Y2) 
     { 
      p1.setLocation(X1, Y1); 
      p2.setLocation(X2, Y2); 
     } 

     public Rectangle2D getBounds2D() 
     { 
      return new Rectangle((int) getX1(), (int) getY1(), (int) (getX2() - getX1()), (int) (getX2() - getY1())); 
     } 
    } 

    public void setXpositions(int ... xPos) 
    { 
     this.xPositions = xPos; 
    } 

    public void setYpositions(int ... yPos) 
    { 
     this.yPositions = yPos; 
    } 

    public void setPositions(int[] yPos, int[] xPos) 
    { 
     setXpositions(xPos); 
     setYpositions(yPos); 
    } 
} 

Plafond:

package levels; 

import domein.Direction; 


public class Ceiling extends Wall 
{ 
    public Ceiling(boolean doodelijk, int[] xPositions, int[] yPositions) 
    { 
     super(doodelijk, Direction.Down, yPositions, xPositions); 
    } 
} 

Answer 1

Êtes-vous sûr de vos paramètres des arguments xposition et yposition? Autrement dit, le plafond est-il vraiment là où vous pensez que c'est? Est-ce la même chose dans vos deux variantes du constructeur?

Answer 2

Je suppose que le problème est dans le code qui vérifie la "collision". Je ne vois pas de problème dans celui que vous avez donné.

Answer 3

Je ne vois aucun problème évident avec vos cours. Il pourrait y avoir un bug ailleurs et vous devrez poster les classes complètes pour que nous puissions l'identifier.