Prosta kolizja dwoch pilek

Odpowiedz Nowy wątek
2018-06-13 16:29
0

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 :)?

edytowany 4x, ostatnio: Maciej Tkacz, 2018-06-13 18:48
W bilardzie są bile, a nie kulki czy piłki… :P - furious programming 2018-06-13 18:03

Pozostało 580 znaków

2018-06-13 17:42
1

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.

edytowany 3x, ostatnio: Spine, 2018-06-13 17:45

Pozostało 580 znaków

2018-06-13 18:46
0

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

Pozostało 580 znaków

2018-06-13 19:14
1

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.

Pozostało 580 znaków

2018-06-13 23:08
0

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

edytowany 2x, ostatnio: Maciej Tkacz, 2018-06-13 23:15

Pozostało 580 znaków

2018-06-14 05:25
1

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 ;)

edytowany 3x, ostatnio: Spine, 2018-06-14 05:27

Pozostało 580 znaków

2018-06-14 11:45
1

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 ;)

Pozostało 580 znaków

2018-06-14 14:04
0

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ć :)

edytowany 3x, ostatnio: Maciej Tkacz, 2018-06-14 14:17

Pozostało 580 znaków

2018-06-14 14:09
1

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.

edytowany 1x, ostatnio: Spine, 2018-06-14 14:09

Pozostało 580 znaków

2018-06-14 14:22
0

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 :)

edytowany 3x, ostatnio: Maciej Tkacz, 2018-06-14 15:50

Pozostało 580 znaków

2018-06-14 19:28
wil
0

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.

Pozostało 580 znaków

Odpowiedz
Liczba odpowiedzi na stronę

1 użytkowników online, w tym zalogowanych: 0, gości: 0, botów: 1

Robot: CCBot