Billard, kugeln berechnung

[poochie89]

Hallo,
ich bin gerade dabei sowas wie ein billard zu programmieren.
für die darstellung verwende ich java swing.
ich habe ball objekte, die eine position speichern, einen a, b und c wert. diese objekte implementieren das runnable interface. in der run methode führt mit hilfe von a, b, c eine fortlaufende positionsänderung aus.
ein objekt pooltisch (jpanel) besitzt mehrere kugeln, eine innere klasse die für den stoß durchführt (mouslistener). wird geklickt wird der abstand zur weißen kugel berrechnet und a, b und c gesetzt. der thread der kugel wird gestartet (die position der kugel fortlaufend verändert), ein weiterer thread zeichnet das spielfeld immer neu. soooo, die weiße kugel läuft nun schon in ordnung, nun zu meinem problem: trifft die weiße kugel auf eine andere soll wenn nicht schon gestartet einen neuen thread erstellen und die kugel rollen lassen (ich überprüfe einfach ob die position jeder kugel einer anderen nahe ist), mein problem ist nun die änderung der laufbahn der kugeln, diese berechnungen scheinen mir sehr komplex, wie löse ich das am besten.

nochwas: in der angabe steht:Wer Lust auf Realismus hat, kann die Kollision einzelner Kugeln mittels eines 2-dimensionalen elastischen Stoßes realisieren. Also ich wär auch mit Unrealismus zufrieden....

Danke schonmal für die Hilfe

 

[Marco13]

Wo ist poochie?

Sieh erstmal zu, dass du das so hinkriegst, dass nicht jede Kugel ein eigener Thread/ein eigenes Runnable ist - das klingt schrecklich kompliziert, und dann kommt neben dem Physikalisch/mathematischen noch dazu, dass du die Runnables in einer synchronized List verwalten musst und so...

 

[whoopsie]

Moin,

interessantes Projekt.

Ich würde den Spieltisch wie Marco schon sagte die Kontrolle über die Kugeln lassen, d. h. nicht jede Kugel kriegt einen eigenen Thread, sondern die Kugeln werden in dem Spieltisch-Thread iteriert und ggf. verändert oder gar entfernt (weil sie versenkt wurden) :lol: Es gibt sowas wie eine Tischuhr (Spielzeit), welche sich der Spieltisch merkt.

Die Kugeln merken sich ihre Position auf der Fläche des Tisches und ihren Bewegungsvektor... wie auch immer der beschrieben bzw. implementiert wird. Der Tisch kann den Vektor für die Kugeln ändern, wenn es erforderlich wird (beim Stoß, angestoßene Kugel, an der Bande, im Loch). Die Kugeln rechnen dann selber für die aktuelle Spielzeit ihre Position aus mit dem Bewegungsvektor, den sie von Tisch bekommen haben. Jede Kugel kann auch ihre Stellung auf dem Tisch mit einem Zeitstempel speichern, wenn sie in Ruhestellung ist (Bewegungsvektor 0), damit kann die Kugel ihre Position auch in der Vergangenheit ermitteln (für Replays oder sowas).

Damit kommst du drum herum immer neue Threads zu starten, wenn eine Kugel sich bewegt. Ferner sind immer alle Kugeln zum Zeitpunkt x auf dem Tisch, wenn ein Thread das macht (bei den paar Kugeln).

Für die Kugeln reicht erstmal als einfaches Modell:
- merke dir die initiale kinetische Energie (abhängig von der Stärke des Stoßes), die die Kugel erfährt und lass diese von der Kugel einfach linear mit der Zeit runterrechnen, damit sie nicht ewig rollt
- die Geschwindigkeit^2 ist proportional zur Energie
- Kugeln, die von anderen Kugeln angestoßen werden erhalten einen prozentualen Anteil der Energie der anstoßenden Kugel
- Kugeln verlieren Energie bei Berührung (Bande, andere Kugeln), abhängig vom Aufschlagwinkel... (10° ~ 50%, 20° ~ 25%, 30° ~ 15%, ca. 70° ~ 10%)
- den neuen Bewegungsvektor berechnet jede Kugel aufgrund ihres Aufschlagwinkels neu (bei Bande Einfalls- gleich Ausfallswinkel)
- bei Kugeln ergibt sich der neue Bewegungsvektor abhängig von der Energie und dem Einschlagswinkel... je mehr Energie, desto weniger "Kursänderung"

Gruß