Andorra 2d Billardspiel in 2d

[Noobmaster]

Habe nun versucht die Formel von Wikipedia auch umzusetzen, nachdem ich mich wieder mal eingehend mit Vektorrechnung abgemüht habe, aber es funktioniert einfach nicht.

Kann mir bitte einer sagen, wie ich einen sich bewegenden Kreis korrekt von einer gerade g(x)=m*x+n abprallen lasse? Habe bisher noch keine Formel gefunden, die ich verstanden habe.

[Sinderion]

Statt der Spiegelungsmatrix solltest du es eher mit einer Rotationsmatrix versuchen.

Grundidee wäre, dass du jede Situation auf eine einfachere zurückführst, indem du das Koordinatensystem entsprechend drehst.
Wenn die Kugel auf eine nicht waagrechte(oder auch senkrechte) gerade fällt, drehst du das Koordinatensystem um eben jenen Winkel, sodass du den einfacheren Fall einer Gerade parallel zur x oder y - Achse hast. Hier die neue Richtung berechnen und anschließend wieder zurückdrehen.

Rotiert werden muss nur die Richtung.

Infos zur Rotation: Drehmatrix

Ich hoffe in der Skizze erkennt man einigermaßen was ich meine (Paint )

[Noobmaster]

Danke für deine Antwort!

Leider funktioniert mein Programm noch nicht so ganz. Hier mein Lösungsansatz:

Delphi-Quellcode:

              VekBande := TVek2d.Create;
              VekBande.x := 1;
              VekBande.y := m[j];

              //Drehwinkel:
              Alpha := VekToWinkelinGrad(VekBande) - VekToWinkelInGrad(Richtung);
              Alpha := DegToRad(Alpha);

              //Neue Richtung:
              Richtung.x := Richtung.x * (cos(Alpha)-sin(Alpha)); //richtige Rechnung???
              Richtung.y := Richtung.y * (sin(Alpha)+cos(Alpha));

              FreeAndNil(VekBande);

Zur Ergänzung noch meine Vektor-To-Winkel Umrechnung:

Delphi-Quellcode:

  function VekToWinkelinGrad(Vektor: TVek2d): Real;
  var
     m: Real;
  begin
     //Umwandlung des Vektors in eine Steigung, m=->y/->x,Sonderfälle beachten!
     if Vektor.x = 0 then
     begin
        if Vektor.y > 0 then Result := 270;
        if Vektor.y < 0 then Result := 90;
     end else
     if Vektor.y = 0 then
     begin
        if Vektor.x > 0 then Result := 0;
        if Vektor.x < 0 then Result := 180;
     end else
     begin
        m := Vektor.y / Vektor.x; //entspricht tan(alpha)
        Result := arctan(m);  //Achtung Bogenmaß!
        Result := RadToDeg(Result);
        if Result < 0 then  //Negativen Winkel umwandeln in positiven
           Result := 360 + Result;
     end;
  end;

Ich hoffe, ihr könnt mir Helfen und bedanke mich schonmal...

Gruß,

Noobmaster

[Noobmaster]

Zitat von Sinderion:

Wenn die Kugel auf eine nicht waagrechte(oder auch senkrechte) gerade fällt, drehst du das Koordinatensystem um eben jenen Winkel, sodass du den einfacheren Fall einer Gerade parallel zur x oder y - Achse hast. Hier die neue Richtung berechnen und anschließend wieder zurückdrehen.

Ich hoffe in der Skizze erkennt man einigermaßen was ich meine (Paint )

Ja, die Skizza ist logisch ^^: Einfallswinkel = Ausfallswinkel, Klass6

2. Lösungsansatz. Er sieht vom Ergebnis her besser aus, aber irgendetwas ist noch falsch:

Delphi-Quellcode:

              //Neue Richtung:
              Richtung.y := Richtung.y * (cos(Alpha)-sin(Alpha));
              Richtung.x := Richtung.x * (sin(Alpha)+cos(Alpha));
              Richtung.y := -Richtung.y;

Ich glaube, ich muss den Vektor nochmal drehen oder so, aber ich steh grade total auf'm Schlauch...

[Noobmaster]

"Bei der passiven Drehung wird das Koordinatensystem gedreht und damit der Vektor mit dem Uhrzeigersinn gedreht. Die Koordinaten des Vektors im gedrehten Koordinatensystem findet man durch Multiplikation mit der Matrix R_alpha^-1:" (Wikipedia)

Ich muss also meinen Vektor "Richtung" mit R_alpha^-1 multiplizieren, oder?

Alpha:
alpha = arctan(Steigung der Geraden) - arctan(Richtung.y/Richtung.x)
stimmt das?

Dann also Richtung*R_alpha^-1.
Ist es richtig, dass R_alpha^-1 = (sin(alpha)+cos(alpha)|cos(alpha)-sin(alpha) ist?

Wenn ich den Vektor dann (hoffentlich richtig?) gedreht habe, dann kann ich die Kugel doch abprallen lassen, indem ich
Richtung.y * (-1) rechne, oder?

Und dann? Bin ich dann fertig oder was fehlt noch genau? Zurückdrehen? Wie?
Wie gesagt, ich weiß einfach nicht, wie ich das hinkriegen soll, die Kugel an der schiefen Gerade richtig abprallen zu lassen...

[Memnarch]

mh..hab zuhause noch ne unit Math3D liegen, die stammt aus nem Tutorial(hab ich von c++ nach Delphi geported) und beinhaltet Klassen für das erstellen und berechnen von Matrizen. Wenn du einfach den Z-wert gleich lässt bei den 3DVectoren, solltest du die so nutzen können. Vorteil ist halt das alles bereits vorhanden ist

Bei bedarf lad ichs hoch.

MFG
Memnarch

[Noobmaster]

Vielen vielen Dank für dein Angebot. Beinahe hätte ich es auch wirklich in Anspruch nehmen müssen .
Habe jetzt nach stundenlangem Kopfzerbrechen - ganz versteckt - eine anscheinend funktionierende Lösung gefunden:

Delphi-Quellcode:

              //Hilfsvektoren:
              VekNormale      := TVek2d.Create;
              VekNeueRichtung := TVek2d.Create;

              //Normale zur Bande bestimmen = Spiegelachse
              VekNormale.x := cos(arctan(m[j]));
              VekNormale.y := sin(arctan(m[j]));

              //Neue Richtung:
              VekNeueRichtung.x := Richtung.x - 2*(Richtung.x*VekNormale.x + Richtung.y*VekNormale.y) * VekNormale.x;
              VekNeueRichtung.y := Richtung.y - 2*(Richtung.x*VekNormale.x + Richtung.y*VekNormale.y) * VekNormale.y;
              Richtung.x := -VekNeueRichtung.x;
              Richtung.y := -VekNeueRichtung.y;

              FreeAndNil(VekNormale);
              FreeAndNil(VekNeueRichtung);

Wie gesagt, anscheinend funktioniert er und das meiste versteh ich sogar .
Wenn ich mein Projekt fertig gestellt habe, dann poste ich vielleicht mal ein Tutorial dazu, da das Programmieren eines eigenen Billardspiels offensichtlich sehr beliebt ist.

[Memnarch]

Ich hoffe du machst da noch methoden wie VecToAngle oder RotateVector

Bin mal auf das spiel gespannt


MFG
Memnarch