Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Werbeanzeige

Patrick

Alter Hase

  • »Patrick« ist der Autor dieses Themas

Beiträge: 1 264

Wohnort: Düren

Beruf: Fachinformatiker für Anwendungsentwicklung

  • Private Nachricht senden

1

22.04.2003, 12:01

2D-Mathefrage

Hi,

ich benutz DG in 2D mit ner Ortho, nun hab ich aber ein Problem: Wenn ich die Rechtecke (per Matrix) drehe funzt die normale Rect Kollision nicht mehr. Wie kann ich testen ob sich 2 Rechtecke schneiden? Das erste Rechteck ist um 10° Gedreht das andere um 66°.

Wie geht das?? Kann mir jemand etwas code geben? ich bin hier schon seit Stunden auf meinem Blatt papier am Kritzeln und such ne Formel/Algo dafür. Vergebends :crying:

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

2

22.04.2003, 12:57

Es ist einfacher, wenn Du das eine Rechteck garnicht drehst, dafür das andere um 66° - 10°, also um 56°. Dann kannst Du zumindest teilweise so arbeiten, wie Du es gewohnt bist.

Patrick

Alter Hase

  • »Patrick« ist der Autor dieses Themas

Beiträge: 1 264

Wohnort: Düren

Beruf: Fachinformatiker für Anwendungsentwicklung

  • Private Nachricht senden

3

22.04.2003, 13:01

und wie teste ich dann auf kollision?? Ich hab echt keinen Plan :( Und wie nicht drehen? Ich muss doch drehen sonst sieht das doch net aus?!?!

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

4

22.04.2003, 13:51

Klar, Du musst schon drehen - beim Zeichnen. Aber beim Rechnen reicht es, wenn Du eins der beiden Rechtecke drehst, dann ist es einfacher. Hauptsache ist, dass die Winkeldifferenz gleich bleibt. Ob ein Rechteck um 10° gedreht ist und das andere um 100° oder ob das eine um 0° und das andere um 90° gedreht ist, ist da egal. Zeig mal Deinen Code für zwei nicht gedrehte Rechtecke.

Patrick

Alter Hase

  • »Patrick« ist der Autor dieses Themas

Beiträge: 1 264

Wohnort: Düren

Beruf: Fachinformatiker für Anwendungsentwicklung

  • Private Nachricht senden

5

22.04.2003, 15:10

Hier meine Struktur und den Code:

Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class CBase
{
public:
    CBase (void);

    void setX           (int iX)            { this->m_iX = iX; }
    void setY           (int iY)            { this->m_iY = iY; }
    void setWidth       (int iWidth)        { this->m_iWidth = iWidth; }
    void setHeight      (int iHeight)       { this->m_iHeight = iHeight; }
    void setCollidable  (bool bCollidable)  { this->m_bCollidable = bCollidable; }

    bool isCollidable   (void)              { return (this->m_bCollidable); }
    bool collidesWith   (CBase &object);

    int getX        (void) { return (this->m_iX); }
    int getY        (void) { return (this->m_iY); }
    int getWidth    (void) { return (this->m_iWidth); }
    int getHeight   (void) { return (this->m_iHeight); }

protected:
    int             m_iX;   
    int             m_iY;   
    int             m_iWidth;   
    int             m_iHeight;  
    bool            m_bCollidable;  
};

#endif


und hier die funktionen:

Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
CBase::CBase (void)
{
    this->m_iWidth = 0 ;
    this->m_iHeight = 0 ;
    // By default, an object is collidable
    this->m_bCollidable = true ;
}

bool CBase::collidesWith (CBase &object)
{
  return (this->m_iX + this->m_iWidth > object.getX () &&
          this->m_iY + this->m_iHeight > object.getY () &&
          this->m_iX < object.getX () + object.getWidth () &&
          this->m_iY < object.getY () + object.getHeight () &&
          object.isCollidable());
}

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

6

22.04.2003, 15:31

Zwei Rechtecke können sich aber auch schneiden, ohne dass irgendein Eckpunkt des einen im anderen Rechteck liegt.
In der Kollisionsfunktion solltest Du vielleicht an allererster Stelle "isCollidable()" abfragen. Es könnte nämlich sein, dass sonst zuerst die anderen Bedingungen untersucht werden und erst zuallerletzt diese einfache bool-Bedingung, die dann alles über den Haufen wirft.
Ich wäre eher für sowas hier:

if(!isCollidable()) return false;

Bei einer "&&"-Verknüpfung darf der Compiler selbst entscheiden, was er zuerst auswertet, und es könnte sein, dass "isCollidable()" erst ganz am Ende drankommt.

Bei drehbaren Rechtecken müsstest Du mit Sinus und Kosinus arbeiten. Aber das ganze ließe sich vermeiden, wenn Du stattdessen Kreise verwenden würdest. Da ist auch die korrekte Kollisionserkennung viel einfacher.

Patrick

Alter Hase

  • »Patrick« ist der Autor dieses Themas

Beiträge: 1 264

Wohnort: Düren

Beruf: Fachinformatiker für Anwendungsentwicklung

  • Private Nachricht senden

7

22.04.2003, 18:12

Naja, das mit Kreisen ist so ne Sache, ich bräuchte eigentlich Rechtecke. Das mit Kreisen wäre ja sogesehen kein Problem. aber es müssen Rechtecke sein. :headscratch:

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

8

22.04.2003, 18:49

Wenn Du es weiterhin nach dem (nicht ganz korrekten) Prinzip "Wenn ein Eckpunkt des einen Rechtecks im anderen drinliegt, dann schneiden sich die Rechtecke" machen willst, dann könnte es so gehen...

Wie gesagt: Das Eine Rechteck dreht sich bei der Berechnung nicht, dafür beinhaltet das andere schon die Rotation des einen. Also werden zwei Rechtecke mit den Winkeln 50° und 90° so behandelt wie eins mit 0° (da ist es einfach, zu testen, ob ein Punkt drin liegt - weißt Du ja) und eins mit 90° - 50° = 40°.

Jetzt nimmst Du Dir die vier Eckpunkte des gedrehten Rechtecks und rechnest ihre relative Position zum Mittelpunkt des Rechtecks aus. Dann kannst Du sie mit folgender Formel drehen:

x' = x * cos(Winkel) - y * sin(Winkel)
y' = x * sin(Winkel) + y * cos(Winkel)

Das müsste jetzt gegen den Uhrzeigersinn sein. Für die andere Richtung einfach "-Winkel" anstatt "Winkel". Jetzt hast Du die rotierten Positionen der Eckpunkte, relativ zum Mittelpunkt. Die Mittelpunktskoordinaten addierst Du jetzt wieder, damit Du die absoluten Koordinaten der Eckpunkte hast.
Jetzt kannst Du einfach testen, ob einer dieser Punkte im anderen - nicht gedrehten - Rechteck liegt.

Am besten nicht alle Punkte nacheinander drehen, sondern immer nur einen, und dann testen, ob er im anderen Rechteck liegt. Falls ja, kannst Du direkt aufhören und Dir die anderen Berechnungen sparen.

Patrick

Alter Hase

  • »Patrick« ist der Autor dieses Themas

Beiträge: 1 264

Wohnort: Düren

Beruf: Fachinformatiker für Anwendungsentwicklung

  • Private Nachricht senden

9

22.04.2003, 19:48

dank dir, ich glaub du hast mich da auf eine Idee gebracht :) :bigok:

Werbeanzeige