Rectangle2D.Double -- intersects() Frage

[Kingkook]

Liebe Com,

ich habe eine Grafik in einem Vektor liegen.Diese ( bewegliche ) Grafik soll darauf überprüft werden,ob sie mit einer anderen unerlaubten Grafik ( in einem anderen Vektor liegend ) kollidiert.Ich habe eine Kollision hinbekommen und sie wird auch erkannt.aber leider nur an den Grafikenden, die vom Ursprung ausgehen ( also bei einem Bild von 30x 30 Pixeln von x = 0 bis x = 30 sowie y = 0 bis y =30 ) aber leider nicht an den andern beiden Seiten.Woran kann das liegen?

public boolean wayCollied(Graphicelements g)
            {
                if (this.intersects(g) && g.getField() == false)
                 {
                    return true;
                 }
                else
                 {
                    parent.allowedX=(int)this.getX();
                    parent.allowedY=(int)this.getY();
                    return false;
                 }
            }

 

[SlaterB]

Problem noch aktuell?
sind das deine eigenen Klassen, hast du intersects() selber implementiert oder gehts auch um API-Klassen?
kannst du nicht genau debuggen, wer an welcher Positition ist, welche einzelnen x-Werte miteinander verglichen werden usw.?

 

[Kingkook]

Also ja das Problem ist noch aktuell.
Es geht um die API Klassen.Meine Klasse erbt von Rectangle2D.Double ( wie u.a. im Tutorial zur Spieleprogrammierung beschrieben), ich selbst habe an diesen nichts verändert.Er bekommt auf jedenfall die richtigen Werte übergeben,aber ich wüsste nicht wo genau ich sehen soll,wieso es nicht so klappt wie es soll....

 

[SlaterB]

also du musst herausfinden oder zumindest mir erklären, wie dein Programm funktioniert,
wovon die Frage abhängt, ob eine Kollision stattfindet oder nicht,

ist [c]this.intersects(g)[/c] der entscheidene Code?
intersects()-Methoden gibt es fast unendlich viele in der API, du musst genauer erklären welche Klassen beteiligt sind,
einmal die Klasse mit der Methode (this) und auch der Parameter (g)

ich gehe mal davon aus, dass alles Rectangle2D sind,
so, dazu kann man den Quellcode in der API nachschauen, dürfte folgender sein:

    /**
     * Tests if the interior of the<code>Shape</code> intersects the 
     * interior of a specified <code>Rectangle2D</code>.
     * @param r the specified <code>Rectangle2D</code>
     * @return <code>true</code> if the <code>Shape</code> and the 
     * 		specified <code>Rectangle2D</code> intersect each other; 
     * 		<code>false</code> otherwise.
     */
    public boolean intersects(Rectangle2D r) {
	return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
    }

    /**
     * Tests if the interior of this <code>Rectangle2D</code> 
     * intersects the interior of a specified set of rectangular 
     * coordinates.
     * @param x,&nbsp;y the coordinates of the upper left corner
     * of the specified set of rectangular coordinates
     * @param w the width of the specified set of rectangular
     * coordinates
     * @param h the height of the specified set of rectangular
     * coordinates
     * @return <code>true</code> if this <code>Rectangle2D</code>
     * intersects the interior of a specified set of rectangular
     * coordinates; <code>false</code> otherwise.
     * @since 1.2
     */
    public boolean intersects(double x, double y, double w, double h) {
	if (isEmpty() || w <= 0 || h <= 0) {
	    return false;
	}
	double x0 = getX();
	double y0 = getY();
	return (x + w > x0 &&
		y + h > y0 &&
		x < x0 + getWidth() &&
		y < y0 + getHeight());
    }

den kannst du dir testweise kopieren, allein erstmal zum Debuggen,
das geht mit einem Debugger oder alternativ ganz simpel mit System.out.println-Befehlen

irgendwo fängt dein Problem an, da gehört hin
[c]System.out.println("vergleiche nun A (x,y) mit B (x,y)"); [/c]
die Koordinaten natürlich richtig ausgeben

dann genau anschauen was Zeile für Zeile passiert

    public boolean intersects(double x, double y, double w, double h) {
	if (isEmpty() || w <= 0 || h <= 0) {
            System.out.println("Ergebnis ist vollkommen false "); // bei näherem Interesse isEmpty() loggen 
	    return false;
	}
	double x0 = getX();
	double y0 = getY();
	boolean b = (x + w > x0 &&
		y + h > y0 &&
		x < x0 + getWidth() &&
		y < y0 + getHeight());
       System.out.println("Standard-Ergebnis ist "+b); // bei Unverständnis jeden Einzelvergleich loggen
       return b;
    }

wenn du den Grund gefunden hast kann man noch überlegen was zu tun ist,
ob du als Parameter an die intersect-Methode irgendwo 1 addierst oder subtrahierst oder eine eigene intersect-Methode verwendet oder das doch schon das richtige Ergebnis ist

 

[Kingkook]

Ich habe mich heute ein wenig rangesetzt und die intersects-Geschichte ein wenig verändert.Konnte so einige Probleme lösen, aber das haupt Problem besteht noch immer und ich weiß jetzt auch welches es ist.Ich habe als "Hintergrund" eine Struktur aus 16x15 Bildplatten zu je 50x50 px, welche alle in einem Vector liegen welcher also demzufolge 192 Elemente enthält.Mein creep ( im Codebeispiel "this" ) selbst ist 30 x 30 px und auch eine Bildplatte, jedoch in einem anderen Vektor.Bei der Kollisionsabfrage wird geprüft, ob mein creep mit EINER Bildplatte kollidiert und ob er mit ebend dieser kollidieren darf.Problematisch wird es nur an den Ecken.

Meine Methode überprüft immer,ob die angrenzenden Felder ( Nord,Süd,Ost,West) betreten werden dürfen.Sobald ich aber an einer Ecke stehe und mein Creep auf 2 Feldern steht, denkt er er ist trotzdem nur auf einem ( in diesem Beispiel in Feld 1 ).Daher denkt er er darf in Feld 2 gehen und lässt mich sü über den Rand hinaus obwohl die untere Hälfte des Creeps ja noch in Feld 3 ist und eigentlich nicht Feld 4 berühren dürfte.
Wie könnte ich das lösen?Stell mich da iwie zu doof an...

 

[SlaterB]

> Sobald ich aber an einer Ecke stehe und mein Creep auf 2 Feldern steht, [--> ]

ist 'ich' == 'mein Creep' oder gibt es da zwei Akteue?

> [--> ] denkt er er ist trotzdem nur auf einem ( in diesem Beispiel in Feld 1 ). Daher denkt er er darf in Feld 2 gehen

ist 'er == 'ich' == 'mein Creep' oder ein dritter oder einer von den obigen beiden, == 'mein Creep' aber != 'ich?

für mich ist es schwer da irgendwas zu verstehen,
aber selbst wenn, dann hängt doch alles von Dingen ab wie 'denkt dass .. in .. ist/ gehen darf', die du gar nicht näher erläuterst,

insofern kann ich derzeit quasi nur mein vorheriges Posting wiederholen: wenn irgendwelche Berechnungsergebnisse oder aktuelle Zwischenzustände/ Positionen unklar sind, dann Loggen Loggen Loggen, so dass du zu jeden Zeitpunkt exakt weißt was in jedem Bit des Arbeitspeichers los ist,

wie du allgemein auf Logikebene deine Bewegung steuerst, möchte ich ungern mit neuen Ideen weiterführen,
falls es sein muss kannst du ja versuchen alles verständlicher erklären, vielleicht dann doch oder wer anders

 

[Quaxli]

Ein bißchen Code wäre nicht schlecht. Programmier das doch mal abstrakt nur mit farbigen Rechtecken, so daß man es kompilieren kann.

 

[Kingkook]

> Sobald ich aber an einer Ecke stehe und mein Creep auf 2 Feldern steht, [--> ]

ist 'ich' == 'mein Creep' oder gibt es da zwei Akteue?

> [--> ] denkt er er ist trotzdem nur auf einem ( in diesem Beispiel in Feld 1 ). Daher denkt er er darf in Feld 2 gehen

ist 'er == 'ich' == 'mein Creep' oder ein dritter oder einer von den obigen beiden, == 'mein Creep' aber != 'ich?

Ja, er == ich == creep ;-)
Ich weiß das war schlecht ausgedrückt,aber ich wollte nicht ständig mit Wortwiederholungen glänzen.

für mich ist es schwer da irgendwas zu verstehen,
aber selbt wenn dann hängt doch alles von Dingen wie 'denkt dass .. in .. ist/ gehen darf' die du gar nicht näher erläuterst,

Also ich probiere es einfach noch mal

Es gibt ein Creep.Dieser erkennt durch diese methode seine aktuelle Position auf dem Vektor, welcher die Wegplatten ( diese sind begehbar ) und die Grasplatten ( nicht begehbar ) enthält.

        public int getActualPosition(Creeps creep)
            {
               int pos;
               int x = (int)creep.getCenterX();
               int y = (int)creep.getCenterY();
               pos =(((x*12)/600))+((((y*16)/800)*16));
               return pos ;
            }

Während sich das Creep bewegt wird geprüft ob das Creep sich dort bewegen darf durch

    private void moveObjects()
        {
            for(Moveable mov:actors) //für alle Objekte in actors --> Einheiten
                {             
                    try
                        {
                            if (creep.wayCollied(ground.elementAt(getActualPosition(creep)+1),ground.elementAt(getActualPosition(creep)+16),ground.elementAt(getActualPosition(creep)-1),ground.elementAt(getActualPosition(creep)-16),ground.elementAt(getActualPosition(creep)+1).getField(),ground.elementAt(getActualPosition(creep)+16).getField(),ground.elementAt(getActualPosition(creep)-1).getField(),ground.elementAt(getActualPosition(creep)-16).getField()))
                                {
//falls sich Einheit hier nicht aufhalten darf wird Creepauf angehalten und auf die letzte erlaubte Position gesetzt
                                    creep.setHorizontalMovings(0);
                                    creep.setVerticalMovings(0);
                                    creep.setY(allowedY);
                                    creep.setX(allowedX);

                                }
                            else
                                {
//falls sich Einheit hier nicht aufhalten darf wird Creepauf bewegt
                                    mov.move(delta);
                                }
                        }
                    catch(ArrayIndexOutOfBoundsException a)
                        {   
                            System.out.println("ArrayIndexOutOfBoundsException während einer Bewegung");
                        }
                    }
        }

Die Überprüfung erfolgt durch die Übergabe von den angrenzenden Bodenplatten ( ausgehend von der aktuellen Position ), sowie den boolean der beschreibt, ob sich das Creep dort aufhalten dürfte, oder nicht.Dann werden die relevanten Koordinaten übergeben

    public boolean crashed(Rectangle2D east,Rectangle2D south,Rectangle2D west,Rectangle2D north,boolean boolEast,boolean boolSouth,boolean boolWest,boolean boolNorth)
    {   
        return crashedCheck(east.getX(), south.getY(), west.getX()+west.getWidth(), north.getY()+north.getHeight(),boolEast,boolSouth,boolWest,boolNorth);
    }

und am Ende wird true oder false ausgegeben, je nachdem ob er mit einem Grasfeld kollidiert oder nicht.

    public boolean crashedCheck(double east, double south, double west, double north,boolean boolEast,boolean boolSouth,boolean boolWest,boolean boolNorth)
        {
            if (isEmpty())
                {
                    return false;
                }
            double creepWest = getX();
            double creepNorth = getY();
            double creepEast = getX()+getWidth();
            double creepSouth = getY()+getHeight();
            return ( ( creepWest-2 < west && boolWest == false && creepWest > 51 ) || ( creepNorth-2 < north && boolNorth == false && creepNorth > 51  ) || ( (creepEast > east ) && boolEast == false && creepEast < 749 )|| ( creepSouth > south && boolSouth == false && creepSouth < 549 ));
        }

So das ist ersteinmal der Ablauf. Und mein Problem mit dieser Vorgehensweise ist wie bereits oben beschrieben:

Da die Position anhand des Mittelpunktes von Creep berechnet wird,befindet sich Creep teilweise laut getActualPosition(creep) auf einem Feld,ist aber schon mit der anderen Hälfte im nächsten Feld.Dadurch kann es passieren,Dass er an Wegabbiegungen durch die Ecke hindurch gehen kann.

Wie könnte ich das am einfachsten umgehen??

Danke für die starken Nerven Kooki

 

[SlaterB]

nochmal nur auf den Text des ersten Postings mit dem Bild bezogen:
wieso betrachtest du gerade eine Ecke, wäre es nicht auch auf eine Geraden (1 + 3 Weg, der Rest grün) bzw. bei selbst bei einem einzigen Feld schon schlimm,
wenn sich die Figur am Rand eines Feldes halb im nächsten drin aufhält?

grundsätzlich könnte man der Figur vorgeben, immer nur vom Mittelpunkt eines der roten Rechteckte zu einem nächsten Mittelpunkt zu gehen,
und auch nur gerade, von 3 nach 1, nicht von 3 schräg rüber nach 2 (oder wenn dann im Halbkreis..),
was spricht dagegen?

darf sich die Figur generell innehalb eines Feldes bewegen?
die Figur wird doch eine Ausdehnung haben, x, y, breite, höhe, darum ging es ja ursprünglich,
dann muss man wiederum nur richtig rechnen so dass es gar nicht dazu kommen kann dass auch nur ein Pixel von braun auf grün rüberwandert,

eine Ecke ist da in der Tat bisschen schwieriger, da sich die Figur vielleicht in Feld 1 befindet, rechts unten aber in Feld 4 hineinreicht,
darum gehts dir vielleicht, jetzt bin auch dort angelangt?
was genau du alles testet habe ich mir noch nicht angeschaut, aber Einbeziehung der Nachbarfelder ist ja recht naheliegend,
das ganze Feld 1 ist schließlich brauner Weg, innerhalb dieses Feldes ist überhaupt nichts zu prüfen, jedenfalls kein grüner Rasen?

 

[Kingkook]

nochmal nur auf den Text des ersten Postings mit dem Bild bezogen:
wieso betrachtest du gerade eine Ecke, wäre es nicht auch auf eine Geraden (1 + 3 Weg, der Rest grün) bzw. bei selbst bei einem einzigen Feld schon schlimm,
wenn sich die Figur am Rand eines Feldes halb im nächsten drin aufhält?

Nein ich habe nur bei Ecken eine kleine Lücke durch die er schlüpfen kann.Bei geraden habe ich kein Problem.

grundsätzlich könnte man der Figur vorgeben, immer nur vom Mittelpunkt eines der roten Rechteckte zu einem nächsten Mittelpunkt zu gehen,
und auch nur gerade, von 3 nach 1, nicht von 3 schräg rüber nach 2 (oder wenn dann im Halbkreis..),
was spricht dagegen?

Grundsätzlich nichts,da dort irgendwann eh nur KI durchlaufen soll,aber sicher ist sicher wenn es auch funktioniert wenn Sich creep frei bewegen kann/darf.

darf sich die Figur generell innehalb eines Feldes bewegen?

ja...noch ja ^^

eine Ecke ist da in der Tat bisschen schwieriger, da sich die Figur vielleicht in Feld 1 befindet, rechts unten aber in Feld 4 hineinreicht,
darum gehts dir vielleicht, jetzt bin auch dort angelangt?

genau das mein ich ;-)

das ganze Feld 1 ist schließlich brauner Weg, innerhalb dieses Feldes ist überhaupt nichts zu prüfen, jedenfalls kein grüner Rasen?

er überprüft trotzdem das komplette feld.da aber kein rasen in feld 1 ist,darf creep raufgehen...

 

[SlaterB]

nun, nach kurzer Durchschau des danach geposteten Codes bin ich nicht schlauer als vorher,
selbst formatiert ist Code a la

if (creep.wayCollied(ground.elementAt(getActualPosition(creep) + 1), ground.elementAt(getActualPosition(creep) + 16),
                             ground.elementAt(getActualPosition(creep) - 1), ground.elementAt(getActualPosition(creep) - 16),
                             ground.elementAt(getActualPosition(creep) + 1).getField(),
                             ground.elementAt(getActualPosition(creep) + 16).getField(),
                             ground.elementAt(getActualPosition(creep) - 1).getField(),
                             ground.elementAt(getActualPosition(creep) - 16).getField()))

für sich ohne wirkliche Aussage

----

zwei denkbare Vorgehensweisen:
1.
Pixelgenau rechnen, für das problematische Eck-Bild kann auf irgendeine Weise ausgerechnet werden, dass die vier aktuellen Ecken der Figur
x1,y1, x2,y2 x3,y3, x4,y4 in Bildschirmpixeln/ Weltpixeln oder so sind, ganz unabhängig von den Kacheln,

durch irgendeine Berechnung ergibt sich glasklar dass die untere rechte Ecke in Feld 4 liegt, ergo Problem,
das hätte vor der Bewegung auch schon vorausgesehen werden können, die Bewegung war nicht erlaubt

2.
etwas Kachel-orientierter:
durch Ausdehnung der Figur kann man grundsätzlich sagen, dass sie sich in einem gewissen Bereich in der Mitte einer Kachel
problemlos bewegen kann,
wenn man sich ein XXO-Neunerfeld
ABC
DEF
GHK
vorstellt, dann im mittleren davon, in E,

möchte die Figur in den unteren Bereich der aktuellen Kachel, in den Bereich H, dann geht das nur genau dann, wenn
weiter unten ein weiteres Wegstück anschließt,
für Bereich F muss rechts ein Anschluss bestehen,

um in einen der Eckbereiche wie K zu gelangen muss nicht nur sowohl rechts als auch unten ein Weg anschließen,
sondern auch noch schräg rechtsunten ein weiteres

ich denke dein Bild beschreibt, wie sich die Figur im Bereich K von Kachel 1 befindet,
da aber nicht Kachel 2, 3 und 4 alles Wege sind, hätte das verboten werden müssen,

so nur noch umsetzen..

 

[Kingkook]

Endlich kam ich mal wieder dazu weiterzuarbeiten...und endlich konnte ich das Problem lösen.Hätte ich gewusst, dass ich es mir viel zu schwer mache hätt ich mir schon vorher in den Hintern treten können.
Hier wollte ich mich nochmal für deine/eure Hilfe bedanken, welche ich sicher bald wieder brauchen werde.

Lösung ist übrigens folgende:

Statt mit einer rechnerisch kaum nachvollziehbaren und teils unsinnigen Kollisionsabfrage, teste ich jetzt einfach alle 4 Ecken des Creeps auf das jeweilige Feld.

Mit der Methode colliedWith, welche das Objekt creep übergeben bekommt, hole ich mir einfach die koordinaten aller 4 Ecken der Grafik.Mit diesen errechne ich dann auf welcher Feldnummer des Vektors der Hintergrundplatten es momentan in der jeweiligen ecke steht ( also bis zu 4 verschiedene Felder ).
Dann teste ich einfach ob irgendeines dieser Felder nicht begehbar ist und falls es das ist wird true zurückgegeben.Falls alle begehbar sind wird die aktuelle position gespeichert.

        @Override
        public boolean colliedWith(Graphicelements g)
            {
                   int x,xW,y,yH,posTopleft,posTopRight,posBottomLeft,posBottomRight;
                   
                   x = (int)this.getX();
                   xW = (int)this.getX()+(int)this.getWidth();
                   
                   y = (int)this.getY();
                   yH = (int)this.getY()+(int)this.getHeight();
                   
                   posTopleft =(((x*12)/600))+((((y*16)/800)*16));
                   posTopRight =(((xW*12)/600))+((((y*16)/800)*16));
                   posBottomLeft =(((x*12)/600))+((((yH*16)/800)*16));
                   posBottomRight =(((xW*12)/600))+((((yH*16)/800)*16));
                   
                   if (parent.ground.elementAt(posTopleft).getField() == false)
                    {
                       return true;
                    }     
                   if (parent.ground.elementAt(posTopRight).getField() == false)
                    {
                       return true;               
                    }            
                   if (parent.ground.elementAt(posBottomLeft).getField() == false)
                    {
                       return true;               
                    }            
                   if (parent.ground.elementAt(posBottomRight).getField() == false)
                    {
                       return true;               
                    }
                   
                   parent.allowedX=(int)this.getX();
                   parent.allowedY=(int)this.getY();
                   return false ;
            }

Mit diesem boolean entscheide ich dann einfach wie sich creep verhalten soll.Falls ein true übergeben wird setzt er sich einfach an die letzte erlaubte Position zurück.Falls false eintritt,darf er sich normal weiter bewegen.

                            if (creep.colliedWith(creep) == true)
                                {
                                    creep.setY(allowedY);
                                    creep.setX(allowedX);
                                    break;
                                }
                            else
                                {
                                    mov.move(delta);
                                }

Dadurch habe ich alle 4 Ecken abgesichert, und es gibt für creep keine Möglichkeit mehr, über eine Ecke zu laufen oder gar durchzuschlüpfen.



Danke nochmal für die Hilfe und liebe Grüße Kooki

 

[SlaterB]

allgemeiner Tipp: immer so wenig Code-Wiederholungen wie möglich,
in deinen Berechnungen Zeile 12 bis 5 hast du die 4 Zahlen 600, 800, 12 und 16 fest vorgegeben,
wenn du davon eine ändern willst musst du es in allen Zeilen machen,
so sauber untereinander geschrieben hier nicht allzu schwierig, grundsätzlich aber immer ein Problem,

lieber Konstanten verwenden und hier die immer gleiche Rechnung sowieso in eine Methode auslagern:
[c]posTopleft =indexOf(x,y);[/c]
[c]posTopRight =indexOf(xW,y);[/c]
usw. ist viel sauberer

ähnlich, wenn auch noch weniger zu sparen, nichtmal Konstanten dabei:
[c]if (parent.ground.elementAt(posTopleft).getField() == false)[/c]
[c]if (parent.ground.elementAt(posTopRight).getField() == false)[/c]
->
[c]if (machtÄrger(posTopleft))[/c]
[c]if (machtÄrger(posTopRight))[/c]
usw.

kann man vielleicht sogar zusammenfassen:
[c]if (machtÄrger(x,y))[/c]
ohne Zwischen-Indexe der Kacheln hier (4), in der Methode dann natürlich schon (nur eine)

deine ganzen 20 Zeilen könnten sich zu 5 Zeilen Methode + einer Zeile
[c]if (wrong(x,y) || wrong(xW,y) || .. )[/c]
zusammenkürzen lassen

aber so wichtig ist das auch nicht, solange nicht seitenweise Code wiederholt wird,
lieber zu viele Zwischenschritte bei Rechnungen als zu wenige

 

[Kingkook]

wird erledigt chef ;-)

danke für die tipps!!