Andorra 2d Billardspiel in 2d

[Noobmaster]

Danke, manchmal sieht man vor lauter Bäumen den Wald nicht mehr

[Noobmaster]

Hi, habe ein neues Problem, aber weil es immer noch mit dem Billardspiel zu tun hat, schreibe ich meine Frage hier hin.
Ich bin bei den Kugelkollisionen angekommen. Das Problem für mich ist jetzt sehr schwer zu beschreiben. Wann eine Kugel von einer anderen getroffen wird brauche ich selber nicht zu bestimmten, das erledigt Andorra2d für mich. Nun ist es aber das Problem, dass die Kugel in Wirklichkeit keine flüssige Bewegung macht, sondern "Sprünge":

Delphi-Quellcode:

                     X := X + (XSpeed * TimeGap * Energie * 10);
                     Y := Y + (YSpeed * TimeGap * Energie * 10);
                     //Energie neu berechnen
                     Energie := Energie - sqrt(Xspeed*XSpeed + YSpeed*YSpeed) * TimeGap;

Maximalwert der Energie ist übrigens 25.
Das heißt, dass eine Kollision erst erkannt wird, wenn die eine Kugel eventuell schon tief in der anderen steckt, aber dann kann ich die neuen Richtungen nicht mehr ausrechnen (Im Normalfall prallt die Weiße im 90° Winkel ab, also läuft entlang der Senkrechten zu der Gerade durch die beiden Kugelmittelpunkten)
Ich hoffe ihr könnt mir helfen. Bisher habe ich im Internet nichts gefunden, was mir das Problem verständlich näher bringen konnte.

[igel457]

Deshalb solltest du dich in solchen Fällen nicht auf die Kollisionsprüfung von Andorra 2D verlassen, sondern über Vektorgleichungen die möglichen Kollisionspunkte im voraus bestimmen...

[Noobmaster]

Hallo Leute!

Mein Billardspiel ist vorangeschritten (auch wenn es lange gedauert hat).

Die Kugelkollisionen klappen, genauso wie die Kugel-geradeBanden-Kollisionen.

Allerdings tue ich mich mit den Banden in den Ecklöchern schwer. Diese sind nämlich schiefe Flächen und ich habe keine Ahnung wie ich die Abprallrichtung berechnen soll. Die Banden in den Mittellöchern sind nicht im 45°-Winkel sondern knapp weniger als 90°.

Habe mich schon versucht anders zu informieren

Delphi-Quellcode:

              //Steigung der Normalen zur Bande:
              VekNormale := TVek2d.Create;
              VekNormale.x := 1;
              VekNormale.y := -1 / m[j];

              //Richtungsvektor der Kugel an dem Normalenvektor spiegeln:
              //Spiegeln(w an v) = 2*(v*w)/(v*v)*v-w
              Richtung.x := 2*(VekNormale.x*Richtung.x)/(VekNormale.x*VekNormale.x)*VekNormale.x-Richtung.x;
              Richtung.y := 2*(VekNormale.y*Richtung.y)/(VekNormale.y*VekNormale.y)*VekNormale.y-Richtung.y;
              VekNormale.Destroy;
              VekNormale := nil;

Aber so funktioniert es leider nicht...
Anmerkung: "m" ist ein Array für die Steigungen der Geraden, die das jeweilige Bandenstück beschreiben.

Ich wäre sehr dankbar für eure Hilfe,

Gruß,
Noobmaster

[Noobmaster]

Ich komme wirklich nicht weiter.

http://de.wikipedia.org/wiki/Spiegelungsmatrix

Damit kann ich gar nix anfangen...

Weiß einer die Lösung meines Problems?

Im Prinzip will ich folgendes erreichen:
Den Richtungsvektor v=(x,y) meiner Kugel bei der Kollision mit einer beliebigen Gerade g:y=mx+n so verändern, dass die Kugel mit Einfallswinkel=Ausfallswinkel an der Geraden abprallt.

[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...