Und nochmal Kollision - Ball zu Ball

[Airblader]

Ich habe mir gestern schon den Vektorartikel auf wiki angesehen, aber irgendwie werde ich nich schlau draus, was ich groß anders mache.
Kenn mich mit Vektoren halt leider praktisch 0 aus *fg*

air

[Khabarakh]

Zitat von Airblader:

Kenn mich mit Vektoren halt leider praktisch 0 aus *fg*

Dann hast du dir das falsche Thema ausgesucht ^^ . Hier wirst du um Vektoren nicht herumkommen, deshalb würde ich die Winkel liegen lassen und direkt mit Vektoren arbeiten. Du siehst ja, was das sonst für ein Chaos wird .

[Airblader]

Zitat von Khabarakh:

Zitat von Airblader:

Kenn mich mit Vektoren halt leider praktisch 0 aus *fg*

Dann hast du dir das falsche Thema ausgesucht ^^ . Hier wirst du um Vektoren nicht herumkommen, deshalb würde ich die Winkel liegen lassen und direkt mit Vektoren arbeiten. Du siehst ja, was das sonst für ein Chaos wird .

Naja gut, aber gibts dafür irgendwelche Tutorials? Ich hab den leisen Verdacht wir werden dieses Jahr in Mathe sicher keine Vektoren behandeln

air

Edit:
Ok, ich habe nun alles auf Vektoren umgestellt. Allerdings hilft mir das hier nicht viel weiter, denn ich hab in etwa keine Ahnung was das Skalarprodukt u.ä. ist und mein erster Ansatz mit Hilfe von wiki war da nicht arg viel hilfreicher

BigEdit:
Also, nach etwas Hilfe hab ich es nun so:

Delphi-Quellcode:

VL2 := sqrt(VecLength);
SpeedVec.X := (1 / VL2) * DistVec.X; /// Speedvec = normiertes m
SpeedVec.Y := (1 / VL2) * DistVec.Y;

B := Self.FMoveVector.X * SpeedVec.X + Self.FMoveVector.Y * SpeedVec.Y;

VecB.X := B * SpeedVec.X;
VecB.Y := B * SpeedVec.Y;

D := Other.FMoveVector.X * SpeedVec.X + Other.FMoveVector.Y * SpeedVec.Y;

VecD.X := D * SpeedVec.X;
VecD.Y := D * SpeedVec.Y;

VecA.X := Self.FMoveVector.X - VecB.X;
VecA.Y := Self.FMoveVector.Y - VecB.Y;

VecC.X := Other.FMoveVector.X - VecD.X;
VecC.Y := Other.FMoveVector.Y - VecD.Y;

VecK.X := VecB.X + VecD.X;
VecK.Y := VecB.Y + VecD.Y;

Self.FMoveVector.X := VecC.X + VecK.X;
Self.FMoveVector.Y := VecC.Y + VecK.Y;

Dass momentan noch etwas unnötiges berechnet wird, weiß ich, aber so scheinen die vektoren zwar in der richtung zu stimmen, jedoch zu lang zu sein (bälle werdn verdammt schnell).
Ich häng mal noch die Grafik an, die ich von Master of the Wind bekommen habe und nach der ich das gemacht habe.

Edit:
Ok, die Richtung stimmt auch nicht

Ganz großes Edit:
Ich glaube nun hab ichs - basierend auf dem Source von BillardGL *freu*
Ich werd den Code nochmal etwas sortieren, variablen ändern etc. und ihn dann morgen online stellen

[Master of the Wind]

jo glaub hab den Fehler, du musst:

VecA.X := VecB.X - Self.FMoveVector.X;
VecA.Y := VecB.Y - Self.FMoveVector.Y;

für VecD das selbe, schuldigung hab mich vertan...Jetzt müssten aber die Richtungen stimmen...

achja und du hast das vergessen:

Other.FMoveVector.X := VecA.X + VecK.X;
Other.FMoveVector.Y := VecA.Y + VecK.Y;

[Airblader]

Das Setzen für den anderen Ball hatte ich auch drin, aber änderte nicht wirklich was

Habs ja nun wie gesagt mit Hilfe des BillardGL Source selber hinbekommen, aber trotzdem Danke für die Hilfe

Werde nachher den Code posten.

air
Edit:
So hier isser...hab mich entschlossen, die Variablennamen doch so zu lassen, wie sie in BillardGL auch heißen.

Delphi-Quellcode:

dx, dy, dx2, dy2, richtung, abstand2, skalarp, kraftx, krafty: extended;

...

dx2 := Other.FPosition.X - Self.FPosition.X;
dy2 := Other.FPosition.Y - Self.FPosition.Y;
abstand2 := sqrt(dx2*dx2+dy2*dy2);
dx := dx2 / abstand2;
dy := dy2 / abstand2;

richtung := (Other.FMoveVector.X - Self.FMoveVector.X) * dx2 + (Other.FMoveVector.Y - Self.FMoveVector.Y) * dy2;

if richtung < 0 then
begin
        skalarp := 0.9 * (Self.FMoveVector.X*dx+Self.FMoveVector.Y*dy) - (Other.FMoveVector.X*dx+Other.FMoveVector.Y*dy);
        kraftx := dx * skalarp;
        krafty := dy * skalarp;

        Self.FMoveVector.X := (Self.FMoveVector.X - kraftx) * 1;
        Self.FMoveVector.Y := (Self.FMoveVector.Y - krafty) * 1;

        Other.FMoveVector.X := (Other.FMoveVector.X + kraftx) * 1;
        Other.FMoveVector.Y := (Other.FMoveVector.Y + krafty) * 1;
end;

Bei dem *1 kann man jeweils einen Verlustfaktor angeben.

Nu muss ich das für mich noch umschreiben, dass die Kreise ihre Geschw. behalten und nicht, dass sie immer geändert wird - aber das sollte ich hinbekommen

Edit: Oder auch nicht Ich müsste doch eigentlich nur diesen Vektor auf der Mittelpunktlinie (im obigen Bild Vektor b also Beispiel) gleichlang haben wie den Bewegungsvektor des Kreises (also V2), oder?
Und im BillardGL Code wäre das dann wohl skalarp. Soweit zur Theorie...die Praxis hängt bei mir grad etwas *fg*

(Übrigens: Was soll denn das 0.9 als Faktor vor skalarp darstellen? Ein Verlustfaktor kanns eig. nich sein, da der ja später erst dazukommt...)

air

[Master of the Wind]

Also die 0,9 damit wird der Energieverlust beim Stoß eingerechnet...

[Master of the Wind]

Hab den fehler bei mir gefunden *schäm* hehe, ja beim elastischen massegleichen Stoß tauschen sich einfach die Geschwindigkeitsvektoren, das hab ich falsch gemacht. hier die änderung:

VecK.X := VecB.X + VecD.X;
VecK.Y := VecB.Y + VecD.Y;

Self.FMoveVector.X := VecC.X + VecK.X;
Self.FMoveVector.Y := VecC.Y + VecK.Y;

das ist falsch und muss wie folgt sein:

Self.FMoveVector.X := VecC.X + VecB.X;
Self.FMoveVector.Y := VecC.Y + VecB.Y;

Self.FMoveVector.X := VecD.X + VecA.X;
Self.FMoveVector.Y := VecD.Y + VecA.Y;

So gut, habs nachgecodet, und so funktioniert es (zumindest bei mir) hehe...naja...also Frohe Weihnachten euch allen

[Airblader]

Zitat von Master of the Wind:

Also die 0,9 damit wird der Energieverlust beim Stoß eingerechnet...

Aber da kommt später ja nochmal ein Verlustfaktor mit rein -> etwas sinnlos ?!

Naja...ich würde eig. nurnoch gern rausfinden, wie ich es anstellen kann, dass sich die Geschw.vektoren eben nicht tauschen *fg* Also wenn sie aufeinanderprallen, soll jeder seine Geschw. behalten.
Ich denke, die Theorie dafür hab ich (siehe Seite 1 unten), aber irgendwie verzweifel ich an der praktischen Seite.

air

[Khabarakh]

Zitat von Airblader:

Naja...ich würde eig. nurnoch gern rausfinden, wie ich es anstellen kann, dass sich die Geschw.vektoren eben nicht tauschen *fg* Also wenn sie aufeinanderprallen, soll jeder seine Geschw. behalten

Was gibt das denn für einen Sinn ? Damit sie trotzdem beibehalten werden, kannst du einfach die entstehenden Vektoren jeweils mit dem Quotient aus alter und neuer Vektorlänge multiplizieren.

[Airblader]

Danke, werd ich mal probieren

Der Sinn ist, dass das ganze ein simpler Teilchensimulator werden soll und da lernt man ja, dass Teilchen
beim Aufprall nicht langsamer werden, keine Reibung entsteht etc.

air

Edit: Danke, scheint zu funktionieren