Ten artykuł traktuje o problemie zachowania się ciał podczas kolizji z uwzględnieniem ich masy i prędkości. Inaczej mówiąc, które ciało będzie się szybciej poruszać po zderzeniu lub wolniej. Ponadto kod programu odpowiednio wyznacza kierunek odbicia ciał po takim zderzeniu wraz z rotacją obrazu „duszka”. Symulacja jest napisana w DELPHI 5 + OMEGA.

WADA ROZWIĄZANIA: symulacja traktuje ciała jako punkty materialne.

Można zadać pytanie: Jak zachowa się ciało o mniejszej masie lub prędkości podczas zderzenia z ciałem o masie większej lub większej prędkości?…Intuicyjnie nasuwa się odpowiedź, że skutki odczuwane dla tego ciała będą dużo „tragiczniejsze” (czytaj: bardziej odczuwane).
Kolejne pytanie jak TO przedstawić w symulacji lub grze?

Otóż należy odwołać się do dwóch fundamentalnych zasad przyrody: zasada zachowania energii i pędu.
Dla ułatwienia zakładamy, że będziemy mieć do czynienia ze zderzeniami sprężystymi (brak rozproszenia energii zderzających się ciał np. zniszczenie karoserii, choć oczywiście można wprowadzić sobie taki współczynnik pochłaniania energii).

Zanim przejdę do omówienia odpowiedniego algorytmu wprowadzę lub przypomnę wyżej wspomniane zasady odpowiednim rysunkiem poglądowym i wzorami.

(przyjmuję oznaczenia: czcionka pogrubiona oznacza wielkość wektorową)

ZASAD ZACHOWANIA PĘDU

Należy pamiętać, że pęd jest wielkością wektorową stąd p1′ + p2′ = p1 + p2
Gdzie:
p1 – pęd ciała pierwszego przed zderzeniem;
p2 – pęd ciała drugiego przed zderzeniem;
p1′ – pęd ciała pierwszego po zderzeniem;
p2′ – pęd ciała drugiego po zderzeniem;

Pęd ciała wyrażony jest przez iloczyn masy ciała i jego prędkości. Masa ciała nie ulega zmianie (chyba, że uwzględnimy ubytek np. paliwa), ale prędkość tak- zwłaszcza przy zderzeniach.

Dla ułatwienia rozpatrzmy zderzenie na płaszczyźnie (w 3D dojdzie w analogiczny sposób składowa Z)
Zasadę zachowania pędu rozpiszemy na składową w kierunku osi X i osi Y (to samo będzie dotyczyć energii)

p'x1 + p'x2 = px1 + px2
p'y1 + p'y2 = py1 + py2

stąd można wyrazić zmianę pędu przez zmianę prędkości (ta wielkość nas interesuje)

m1V'x1 + m2V'x2 = m1Vx1 + m1Vx2
m1V'y1 + m2V'y2 = m1Vx1 + m2Vx2

W analogiczny sposób postępuje się z energią. W tym wypadku energią kinetyczną, wyrażoną zależnością E=mv^2/2. Poprzez, którą zasadę zachowania energii zapisać można:

E = E1 + E2

Kolejne kroki wyprowadzenia zależności na prędkość ciała po zderzeniu pomijam, można to znaleźć w każdej książce z fizyki. Poniżej podam odpowiednie zależności na składowe wektora prędkości w kierunku osi X i Y, przyjmując oznaczenie u dla nowego wektora prędkości.

Dla ciała pierwszego

Dla ciała drugiego

Jeżeli znamy składowe wektora prędkości, to jesteśmy wstanie wyliczyć kierunek wektora prędkości, czyli kąt w obranym układzie odniesienia, w jakim porusza się nasze ciało lub w jakim będzie się poruszać ciało po zderzeniu (stosunek Vy/ Vx jest tangensem kąta kierunku, Vy/ sqrt(sqr(Vx)+sqr(Vy)) jest sinusem kąta kierunku, można też zastosować cosinus, jak kto woli…)

Powiedzmy, że tyle o fizyce. Możemy teraz przystąpić do napisania symulacji zderzenia ciał. Symulacja będzie uwzględniać:
a) zmianę wartości prędkości po zderzeniu
b) wyznaczać kierunek ruchu po zderzeniu
c) obrót ciała- obrazu zgodnie z kierunkiem ruchu

Pełny opis i dodatkowy komentarz znajduje się w kodzie programu.

Duszek naszego programu żyje dzięki poniższej klasie

gdzie

funkcja Rotacja wyznacza obrót obrazu duszka według poniższego algorytmu
(nie będę się tu rozpisywać nad pojęciem ćwiartki układu odniesienia i radianami)

Fizyka zderzenia ujęta jest w procedurze kolizji, którą przedstawiam poniżej

Tu chciałbym zwrócić uwagę osobą zaczynającym programować obiektowo z użyciem komponentu OMEGI (to samo dotyczy i DELPHIX). Jak zobaczycie w pełnym kodzie programu można wygenerować do 100 ciał i nie ma pętli lub referencji, która by obsługiwała każde ciało z osobna. Za to odpowiedzialne są linie kodu umieszczone w procedurze „zegara” aplikacji. Poniżej przedstawiam (pełna postać w źródle programu)

Poniższa procedura odpowiedzialna jest za ruch duszków ciał.

Można jeszcze przytoczyć postać procedury zderzenia ze ściankami, czyli krawędziami ekranu. Krawędzie ekranu można potraktować jako ciała o bardzo dużej masie (dążącej do nieskończoności w porównaniu z masą ciała uderzającego w krawędź). Jej działanie można zobrazować tym rysunkiem

Zaś procedurę poniższym kodem

Podsumowując najważniejszym elementem tych rozważań jest procedura TCialo.onCollision(const Sprite:Tsprite;const colX,colY:integer)pozostałe procedury są otoczką funkcjonowania programu. Stąd też osoby nie uznające DELPHI powinny zwrócić na nią uwagę. Pozostałe elementy programu oprogramować według własnego uznania.

Pozdrawiam oksal

Autor: oksal

Załączniki