Pong - Problem bei der Ballkollision

[.chicken]

argh dann muss ich ja sauvoiel umschreiben oder?? und du meinst dan reellen typ dann immer wenn ich die pixel abfrage runden oder was???

[Cöster]

Runden brauchst du eig. nur, wenn gezeichnet werden muss. Wieso viel umschreiben?

[.chicken]

Aaaah das geht trotzdem nich ^^
Weil das mit der Schleife meeeeeeeeega kompliziert is....das muss doch auch einfacher gehn...ich guck mir mal nochn paar andere Pong Spiele an!

[Corpsman]

Auch auf die Gefahr hin das ihr mich der Werbung bezichtigt.

es gibt da ein Sample das die Kollision von Bällen in 2D sehr gut zeigt.

[.chicken]

Ok danke, dass seh ich mir ma an, hab naemlich sonst unter der Suche kein Pong gefunden wo man auch die Seiten des Schlaegers anstoßen kann =)

Woah da steig ich nun garnichmehr durch :(

[Corpsman]

Eigentlich ist es ganz Simpel.

Du must ja nur den Teil auserhalb der Class verstehn.

[.chicken]

Alles ausser Class is doch fast das ganze Projekt!? Oder meinste damit alles ausser der Elements.pas?

Da sind soviele Variablen, dass ich bei jeder Prozedur tausend mal nachgucken muss, was das war... :D

Naja dann dauert des ganze halt ma zwei Stunden :P Ich setz mich heute Abend ma dran...

Delphi-Quellcode:

Function EllipseRechteckcollision(E1, R1: Trect): boolean;
Type
  Tpunkt = Record
    X, Y: Extended;
  End;
Var
  SN1, SN2, X, Alpha: extended;
  p1, p2: Tpoint;
  N1, N2: Tpunkt;
  radius1, radius2: integer;
Begin
  result := false;
  If E1.left > E1.right Then tausche(E1.left, E1.right);
  If E1.Top > E1.bottom Then tausche(E1.top, E1.bottom);
  If r1.left > r1.right Then tausche(r1.left, r1.right);
  If r1.Top > r1.bottom Then tausche(r1.top, r1.bottom);
  p1.x := E1.left + ((E1.right - E1.left) Div 2);
  p1.y := E1.top + ((E1.Bottom - E1.top) Div 2);
  p2.x := r1.left + ((r1.right - r1.left) Div 2);
  p2.y := r1.top + ((r1.Bottom - r1.top) Div 2);
  Alpha := arcTangens(p1.x - p2.x, p1.y - p2.y);
  X := Hypot(p1.x - p2.x, p1.y - p2.y);
  Radius1 := p1.x - E1.left;
  Radius2 := p1.y - E1.top; // Radius 1 Horizontal, Radius2 Vertikal
  N1.X := cosinus(alpha) * radius1 + P1.X;
  N1.Y := sinus(Alpha) * radius2 + P1.Y;
  SN1 := Hypot(p1.x - n1.x, p1.y - n1.y);
  Case round(Alpha) Of
    0..45: Begin
        n2.x := R1.right;
        n2.y := round(tangens(alpha) * ((r1.Bottom - p2.y) / 2)) + p2.y;
      End;
    46..90: Begin
        n2.y := R1.top;
        n2.x := round(tangens(alpha - 45) * ((r1.right - p2.x) / 2)) + p2.x;
      End;
    91..135: Begin
        n2.y := R1.top;
        n2.x := round(tangens(alpha - 90) * ((r1.right - p2.x) / 2)) + p2.x;
      End;
    136..225: Begin
        n2.x := r1.left;
        n2.y := round(tangens(alpha) * ((r1.Bottom - p2.y) / 2)) + p2.y;
      End;
    226..270: Begin
        n2.y := r1.bottom;
        n2.x := round(tangens(alpha - 225) * ((r1.right - p2.x) / 2)) + p2.x;
      End;
    271..315: Begin
        n2.y := r1.bottom;
        n2.x := round(tangens(alpha - 270) * ((r1.right - p2.x) / 2)) + p2.x;
      End;
    316..360: Begin
        n2.x := R1.right;
        n2.y := round(tangens(alpha) * ((r1.Bottom - p2.y) / 2)) + p2.y;
      End;
  End;
  SN2 := Hypot(p2.x - n2.x, p2.y - n2.y);
  If (x <= (sn1 + Sn2)) Then result := true;
End;

So also wenn mich nich alles taeuscht ist das doch das was ich suche oder??? Wie man berechnet wie der Ball abprallt wenn er auf ein Rechteck trifft....so und ich steig da mal garnicht durch!!!

Ich hab null Plan davon was du da gemacht hast ^^

Delphi-Quellcode:

  Alpha := arcTangens(p1.x - p2.x, p1.y - p2.y);
  X := Hypot(p1.x - p2.x, p1.y - p2.y);
  Radius1 := p1.x - E1.left;
  Radius2 := p1.y - E1.top; // Radius 1 Horizontal, Radius2 Vertikal
  N1.X := cosinus(alpha) * radius1 + P1.X;
  N1.Y := sinus(Alpha) * radius2 + P1.Y;
  SN1 := Hypot(p1.x - n1.x, p1.y - n1.y);

Speziell mit dem Teil habe ich Probleme also ich verstehs nun soweit, dass du zuerst die Steigung ziwschen den beiden Mittelpunkten ausrechnest, richtig?
Dann nimmst du von der Steigung den ArcTangenten...(ich versteh nur nich wozu :D)
Und dann wofür diese Sinus und Cosinus Funktionen mit den Radien sind versteh ich auch nich ganz ^^

[Corpsman]

Ho

Also ich will mal Versucehn Licht ins Helle zu bringen ;)

Delphi-Quellcode:

function EllipseRechteckcollision(..);

Berechnet wie der Name schon sagt ob ein Rechteck mit einer Ellipse Collidiert.

Wobei Rechteck genau wie Ellipse als Trect übergeben werden ( übrigens genau gleich würdest du sie mit einem Tcanvas Malen lassen ).

dann wird eine Strecke zwischen den Mittelpunkten der beiden Objecte Gebildet und die Länge berechnet.

Danach wird an dieser Lienie geschaut wann sie die schnittpunkte mit der Ellipse und dem Rechteck hat ( das ist das Sinus, Cosinus zeug )

anhand der Schnittpunkte kann dann berechnet werden wie Lang diese Strecken Relativ zur Gesamtstrecke der Mittelpunkte sind. je nach dem hat man dann eine Collision, oder eben nicht.

Das ist es im Prinzip.

Die Berechnung ist nicht 100% aber schon nah dran und immer noch recht schnell. Habe dir mal mein Collision Testprogramm mit dran gehängt. da kannst du Graphisch sehn was die Function macht.

der Grund warum Sinus und Cosinus Functionen liegt an der Umrechnung Bogenmaß Gradmaß.

Je nach schulbildung sagt dir das dann was, oder auch nicht ;)

[.chicken]

Naja..also bin iner 10.Klasse und wir hatten es bisher nur in Mathe Info (wo wir aber leider sonen dummen Lehrer haben, dass wenn man sich nich alles selber beibringt nix lernt).

Somit: es sagt mir recht wenig ^^

Also gut, dass hab ich alles fast verstanden aber der letzte Teil, da guckst du in welchen Winkel sie aufeinander treffen und siehst daran dann von wo der Ball gekommen sein muesste, dh auf welcher Seite vom Rechteck er aufprallt oder?

(Boah das is ja mal viel komplizierter als ich dachte! Jetzt weiss ich zumindest, dass wenn wir das iner Schule durchnehmen ich aufpasse :D)

BTW: Hab mir grad ma dein Spiel angeguckt, Balanced, MEGA GENIAL!! Respekt, nach wievielen Jahren Delphi haste das geschrieben und wie alt warste da??

[Corpsman]

thx für die Blumen.

Balanced habe ich dieses Jahr geschrieben.

also mit 24.

Eigentlich wollte ich ein Sample schreiben das mir mal klar macht wie man Mit OpenGl Programmiert. Weil ich bis dahin nur wuste das es sowas gibt. Nicht aber was es ist. Wie man An Balanced sehen kann ist OpenGl echt easy zu lernen.
Das Game hat mich ungefähr 10- 20 Wochen programmieren gekostet. Dabei sind dann etwa 35000 Zeilen Code entstanden. Die Physik engine habe ich aber nicht komplett gemacht. Im Game sind 3 Physik engines die Hauptengine ist aber definitiv Newton.dll

Aber bei STM einem Kleinen Test, bei dem ich mal schaun wollte ob ich eine 2D physik Engine zusammen bekomme. da ist die Physik schon deutlich mehr aus meiner hand ;)


Was deine Frage angeht :

Du darfst nicht nur schaun aus welcher Richtung die Objecte zusammenstoßen, sondern du must die Objecte auch wieder auseinander rücken, bevor du sie dann Abprallen läst. Sonst bekommst du teilweise recht böse Fehler hin. Desweiteren ist es sehr wichtig das du immer Recht kleine Bewegungen machst ( deiner Kugel ) wenn du das nicht machst must du zusätzlich Prüfen ob du evtl eine Komplette wand "überspringst".

10. Klasse Mathe ist da leider natürlich nicht ganz die Optimale Grundlage. Ich empfehle dir Dringend

Vektorrechnung !!!

Frag das mal deinen Lehrer. oder schau dir die Tutorials an. mit Vektoren werden so 2D und 3D sacehn deutlich einfacher.