Prosta kolizja dwoch pilek

Cześć :)
Chciałbym okodowac dwie kulki ,ktore maja nasladowac bile znane nam z gry bilard Bile maja miec losowa predkosc i odbijac sie miedzy soba .Taka krotka symulacja.

Robie to w C++ CLR w Visula studio . Wczytuje Picturebox dla dwoch bili. Nastepnie animacje tworze wykorzystujac funkcjie z timerem. Dodajac z kazdym wykonaniem funkcji przesuniecie o kilka pikseli np:

pilka->Top +=5; 
pilka->Left +=5; 

kolizja z krawędzią stolu dziala dobrze ,zmieniam po prostu znak dla osi X na przeciwny czyli zamiast dodawać np 5 dodaje -5;

nastepnie licze odleglosc miedzy srodkami obu kul ,stosujac pitagorasa :)

distance = sqrt(   ((pilka->Left + (pilka->Width / 2)) - (pilka2->Left + (pilka2->Width / 2))) *  ((pilka->Left + (pilka->Width / 2)) - (pilka2->Left + (pilka2->Width / 2)))+ ( (pilka->Top + (pilka->Height / 2)) - (pilka2->Top + (pilka2->Height / 2))) * ((pilka->Top + (pilka->Width / 2)) - (pilka2->Top + (pilka2->Width / 2) )));

wykrycie kolizji miedzy bilami:

if ((distance < (pilka->Width / 2)+5 ) &&(z))
{
					
z=false;
}
else if(distance > pilka->Width / 2+5)
{
z=true;//potrzebna jest zmienna bool aby warnek zostal wykonany raz w momencie gdy pilki spelniaja warunek 
}	

no i teraz mam problem musze okodowac realistyczne odbijanie sie bili miedzy soba nie jest to tak latwe jak w przypadku odbic od krawedzi stolu :)

Pytanie mam w jaki sposob opisac wektor predkosci danej kulki ?

Mamy przemieszczenie bili w osi x czyli np pilka->Left +=5; ,mozemy tez zmierzyc czas w jakim te przemisczenie nastepuje , czyli za pomoca zegara systemowego ten czas wyznaczyc , dzielac przepieszczenie przez czas mamy predkosc na osi X czyli Vx ,analogicznie dla osi Y ,

Otrzymamy wektor predkosci V=(Vx )i+(Vy)j ,majac cos takiego jestem wstanie wtedy realnie to okodowac :) tylko jak ten wektor potem zapisac w c++ i wzglednic go w ruchu bili :)?

Wektor prędkości to właśnie x = 5 i y = 5.
Powinieneś ten wektor przechowywać w zmiennej i o niego zmieniać pozycję kuli. Dodatkowo powinieneś przy zwiększaniu pozycji o wektor, mnożyć go przez czas klatki (deltaTime - części setne/tysięczne sekundy). W ten sposób w jedną sekundę, kula przemieści się o 5 jednostek w górę/dół i 5 jednostek w prawo/lewo. Co sprawia, że kula leci z prędkością (5;5) jednostek na sekundę.

W momencie odbicia jednej kuli od drugiej musisz tylko zmienić wektory obydwu kul, przy obliczeniach uwzględniając wektory prędkości obu kul oraz wzajemne położenie - inaczej odbiją się kule które się otarły, a inaczej przy zderzeniu czołowym.

Dzieki wielkie :)
Czas klatki czyli interwał mojej funkcji z timerem ?

To nie do końca interwał, bo obliczenia troszkę trwają w każdym wywołaniu funkcji... No ale w uproszczeniu można tak zrobić.

Tylko jeśli interwał masz w milisekundach, to musisz je zamienić na float (float)interval/1000.0f.

dzieki :)
Miałbyś moze jeszcze pomysl jak z rzutować ten wektor predkosci na linie łaczacą srodki obu bili ?
Znajac srodki bill moge wyznaczyc prosta o danym ronaniu liniowym lub wektor ,nastepnie moglbym policzyc tez kat miedzy wektorem predkosci a linią łacząca oba srodki ,tylko nie wiem co dalej :)
Tu jest to fajnie opisane ,tylko nie dokonca wiem jak to zrobic :)
http://www.obliczeniowo.com.pl/144

Bez teorii kombinowałbym tak (dla każdej bili z osobna):

1. wyliczyć wektor wypadkowy (suma wektorów prędkości obu bil).
2. uśrednić go (podzielić przez 2).
3. wyliczyć wektor między bilami (pozycja1 minus pozycja2).
4. znormalizowany wektor między bilami pomnożyć przez długość uśrednionego wektora wypadkowego.
5. wynik dodać do obecnego wektora prędkości.

1 i 2 będzie takie same dla obu bili; w 3 ważne jest którą pozycję odejmujemy od której, bo od tego zależy zwrot/kierunek wektora.

Gwarancji nie daję, ale pewnie z drobnymi zmianami przejdą tego typu obliczenia ;)

Zderzenie sprężyste, niżej masz opisane zderzenie sprężyste niecentralne... jeśli masy bil są takie same to prawie nic nie musisz liczyć, różne to trochu więcej, do zderzeń niesprężystych wpierw musisz rozumieć zderzenia sprężyste, jeśli dodatkowo bile mają się obracać to + tarcia, moment obrotowy itd itd... fizyka ze szkoły średniej ;)

Korzystajac z idealnie wypunktowanej instrukcji stworzyłem kod :)

//x1 i y1 sa to wspolrzedne wektora predkosci bili nr 1 
//x2 i y2 dla bili nr 2

wektorx =(x1+x2)/2;   ///obliczenie wektora wypadkowego ,skladowa x
wektory = (y1 + y2) / 2;  ///obliczenie wektora wypadkowego ,skladowa y



u11 = (pilka2->Left+(pilka2->Width/2))- (pilka->Left + (pilka->Width / 2)) ; //liczenie wektora imiedzy bilami dla skladowej x 


u12 = (pilka2->Top + (pilka2->Width / 2)) - (pilka->Top + (pilka->Width / 2));  //liczenie wektora imiedzy bilami dla skladowej y


dlugosc = sqrt(wektorx*wektorx + wektory * wektory)  ;  //dlugosc wektora wypadkowego predkosci obu bill


u21 = u11 * dlugosc;   //pomnozenie wektora miedzy  srodkami bill przez dlugosc wektora wypadkowego ,skaldowa x
u22 =u12*dlugosc;    //pomnozenie wektora miedzy  srodkami bill przez dlugosc wektora wypadkowego ,skaldowa y
x1 =+ u21;   //dodanie go do wektora predkosci ,skaldowa x
y1 =+ u22;   //dodanie go do wektora predkosci ,skaldowa y

//analogicznie dla drugiej bili 
u11 = (pilka->Left + (pilka->Width / 2)) - (pilka2->Left + (pilka2->Width / 2));
u12 = (pilka->Top + (pilka->Width / 2)) - (pilka2->Top + (pilka2->Width / 2));
dlugosc = sqrt(wektorx*wektorx + wektory * wektory);
u21 = u11 * dlugosc;
u22 = u12 * dlugosc;
x2 = +u21;
y2 = +u22;

no i nie koniecznie on dziala :)
pileczki troszke wariuja ,moglem czegos nie zrozumiec do konca :)
Odnoszac sie do poprzedniego wpisu ,tak to jest fizyka ze szkołu sredniej :) kwestia jest jak to okodować :)

Do testów mógłbyś po zderzeniu przestać wykrywać kolizję. Jakiegoś boola ustawisz na true i dodasz ifa przy sprawdzaniu kolizji. Bo teraz pewnie piłeczki dopóki są w kontakcie, cały czas robią kod odbicia.

Generalnie miałem takie zabezpieczenie ale mozliwe ze nie koniecznie dobrze działa ,podesle caly kod w petli z timerem :)

				if (pilka->Left > 690)	//warunek odbicia sie od prawej krawedzi stolu
				{
					x1 = -x1;//zmiana wartosci dodawanej do polozenia pileczni X=-X,innicjujaca odbicie
					
				}
				if (pilka->Top > 310)	//warunek odbicia sie od doonej krawedzi stolu
				{
					y1 = -y1;
				}
				if (pilka->Top < 110)//warunek odbicia sie od gornej krawedzi stolu
				{
					y1 = -y1;
				}
				if (pilka->Left < 280)	 //warunek odbicia sie od lewej krawedzi stolu
				{
					x1 = -x1;
				}

				
				
				if (pilka2->Left > 690)	//warunek odbicia sie od prawej krawedzi stolu
				{
					x2 = -x2;
				}
				if (pilka2->Top > 310)	//warunek odbicia sie od doonej krawedzi stolu
				{
					y2 = -y2;
				}
				if (pilka2->Top < 110)//warunek odbicia sie od gornej krawedzi stolu
				{
					y2 = -y2;
				}
				if (pilka2->Left < 280)	 //warunek odbicia sie od lewej krawedzi stolu
				{
					x2 = -x2;
				}

				distance = sqrt(   ((pilka->Left + (pilka->Width / 2)) - (pilka2->Left + (pilka2->Width / 2))) *  ((pilka->Left + (pilka->Width / 2)) - (pilka2->Left + (pilka2->Width / 2)))+ ( (pilka->Top + (pilka->Height / 2)) - (pilka2->Top + (pilka2->Height / 2))) * ((pilka->Top + (pilka->Width / 2)) - (pilka2->Top + (pilka2->Width / 2) )));
				
				
				if ((distance < (pilka->Width / 2) ) &&(z))
				{
					
					label1->Text = Convert::ToString(licznik);
					licznik++;
						//x1 i y1 sa to wspolrzedne wektora predkosci bili nr 1 
						//x2 i y2 dla bili nr 2

						wektorx =(x1+x2)/2;///obliczenie wektora wypadkowego
						wektory = (y1 + y2) / 2;

						//liczenie wektora imiedzy bilami dla skladowej x
						u11 = (pilka2->Left+(pilka2->Width/2))- (pilka->Left + (pilka->Width / 2));
						//liczenie wektora imiedzy bilami dla skladowej y
						u12 = (pilka2->Top + (pilka2->Width / 2)) - (pilka->Top + (pilka->Width / 2));
						//dlugosc wektora wypadkowego predkosci obu bill
						dlugosc = sqrt(wektorx*wektorx + wektory * wektory);
						u21 = u11 * dlugosc;//pomnozenie wektora miedzy  srodkami bill przez dlugosc wektora wypadkowego ,skaldowa x
						u22 =u12*dlugosc;//pomnozenie wektora miedzy  srodkami bill przez dlugosc wektora wypadkowego ,skaldowa y
						x1 = u21; //dodanie go do wektora predkosci ,skaldowa x
						y1 = u22; //dodanie go do wektora predkosci ,skaldowa y

						//analogicznie dla drugiej bili 
						u11 = (pilka->Left + (pilka->Width / 2)) - (pilka2->Left + (pilka2->Width / 2));
						u12 = (pilka->Top + (pilka->Width / 2)) - (pilka2->Top + (pilka2->Width / 2));
						dlugosc = sqrt(wektorx*wektorx + wektory * wektory);
						u21 = u11 * dlugosc;
						u22 = u12 * dlugosc;
						x2 = u21;
						y2 = u22;
					
					z = false;  //zmienna bool o ktorej mowimy  

				}
				else if(distance > pilka->Width / 2+5)
				{
					z = true;   //zmienna bool o ktorej mowimy  

				}

				czas = (float)timer1->Interval / 1000.0f;
				
				pilka->Top += Convert::ToInt32(y1*czas);
				pilka->Left += Convert::ToInt32(x1*czas);
				pilka2->Top += Convert::ToInt32(y2*czas);
				pilka2->Left += Convert::ToInt32(x2*czas);

				
			}

A dodam ze bile sa takie same :)jesli chodzi o rozmiar :)
pileczki wchodza wielkie predkosci ,albo sie zatrzymuja w dziwny sposb :)
dodałem licznik ktory pokazuje ile razy wykonuje sie warunek no i jest dosc dobrze nie wykonuje on sie wiele razy :)

Wyliczasz to w układzie środka masy obu kul.
Potem rozkładasz prędkości na dwie składowe: styczną i normalną do punktu kontaktu.

Po odbiciu składowe normalne się odwracają zwyczajnie: vn = -vn;
a stycznie pozostają bez zmian:

v = (v_t, v_n) -> v' = (v_t, -v_n)
i teraz z powrotem przechodzisz z tym na: vx, i vy.

dzieki za wypowiedz :)
Tylko czemu punkt kontaktu i skladowe normalne i styczne :) Ma tam powstac moment obrotowy :)? Zakladamy ze bile maja ruch postepowy tyllko :)
Problem u mnie polega na tym jak matematycznie i za pomoca c++ , sprawic aby wektor predkosci zrzutowac na prosta łączącą oba srodki i nastapnie te skladowe ze sobą zamienic miedzy wektorami predkosci obu bill , oto ci chodziło ?:)

Dlatego że składowe normalne się tam tylko odwracają... :)
W przypadku obliczania tego wprost w układzie x,y, obliczenia byłyby bardzo skomplikowane.

rzut wektora v na kierunek n:
v_n = (v.n) n; gdzie: v = (vx, vy), n = (nx,ny); oraz |n| = 1

Dobra nazewnictwo jest nie wazne , kluczowe jest to zeby sie dogadali :)
Podajesz mi rozumiem wektor kierunkowy n :)
Jak rowniez skladowa predkosci o kierunku n, nic mi to nie daje :)
Teraz najwazniejsze jest to jak dodkladnie policzyc ile ma wyniosic ta skladowa i okodowac w c++ :)

Gdy masz już tę kolizję dwóch kul, wtedy masz ich pozycję (x,y) w tej chwili...
wówczas ten wektor normalny jest tu po prostu linią wzdłuż środków obu kul:

n = p1 - p2 = (x1-x2,y1-y2); co należy znormalizować: n = n/|n|;

• wyliczasz prędkość środka masy obu kul: V_c = ...
• przeliczasz prędkości do układu środka masy: v' = v - V_c.
• rozkładasz te prędkości na normalną i styczną względem n
• zamieniasz normalne na przeciwne: (vt, -vn)
• odkręcasz te wszystkie transformacje, aby odzyskać z powrotem: vx, vy - potrzebne do rysowania po ekranie...

dzieki ,teraz jest wiele wartosciowych konkretow :)
"przeliczasz prędkości do układu środka masy: v' = v - V_c."

tego etapu nie rozumiem ,moglbys doprecyzowac :)?

Prędkość środka masy wyliczasz z pęd całego systemu, czyli z sumy pędów obu kul:
p_c = M V_c = p1 + p2 = v1 m1 + v2 m2; M = m1+m2

z tego wyliczasz: V_c = ...

dla identycznych kul: m1 = m2.

Mam pewien pomysł:

1. Wykryj kolizję.
2. Oblicz normalną kolizji (jeżeli pozycja1=(1,1), a pozycja2 = (2,3), to normalna będzie równa (1,2) (abs(p1.x-p2.x),abs(p1.y-p2.y))
3. Znajdź normalną ruchu obu bil (jeżeli vx=2, a vy=3, to normalna będzie równa (2,3))
4. Oblicz odbitą normalną prędkości ruchu dla każdej z bil funkcją reflect() (jest to funkcja z GLSL, jej kalkulowanie masz tutaj - https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/reflect.xhtml | https://mathinsight.org/dot_product_examples)
5. Zaaplikuj do bil odpowiednie prędkości (wyniki reflect())

Skoro już lecimy w takie rozwiązania, to możesz swoje kule podpiąć pod silnik fizyczny, np. Box2D.

Przecież tu nie ma czego liczyć - z trzy instrukcje to załatwią.

po wyliczeniu prędkości w środku masy:

vn = (v dot n) n

następnie należy to odbić: vn = -vn;
oraz: vt = v - vn, czyli finalnie modyfikacja prędkości wygląda tu tak:

v -= 2vn.

ponieważ:
v = vt + vn, natomiast nowa prędkość: v = vt - vn
zatem:
v' = (v-vn) - vn = v - 2vn;