[pipok]

Cel - pal!
Dla początkujących

Jeśli chcemy strzelać do wroga lub innego celu:

Kod:

object wrog=radar(AlienAnt); point cel=wrog.position;

powinniśmy upewnić się, że - prócz wystarczającego zapasu energii - spełnione są przynajmniej trzy warunki:
* cel jest w zasięgu strzału
* lufa bota jest w poziomie skierowana na cel
* lufa bota jest w pionie skierowana na cel

1. Zasięg strzału
Wystarczy sprawdzić odległość między botem a celem

Kod:

if (distance(position, cel) < 30) {   // cel w zasięgu }

2. Kierunek lufy w poziomie
Nie ma możliwości programowego obrotu lufy w poziomie, dlatego konieczne jest obrócenie całego bota w kierunku celu

Kod:

turn(direction(cel));

3. Kierunek lufy w pionie
Na niewielkich odległościach tor lotu pocisku można uznać za linię prostą, wtedy lufa powinna być skierowana w pionie prosto na cel.
Odpowiedni kąt nachylenia można policzyć z prostej zależności geometrycznej, po czym obrócić lufę w pionie:

Kod:

H = cel.z - position.z; L = distance2d(cel, position); alfa = atan(H/L); aim(alfa);

Warto jednak pamiętać, że powyższe trzy warunki są warunkami podstawowymi. Prócz tego warto rozważyć:

* ograniczenie kąta obrotu lufy (można obrócić lufę o kąt od -10 do +20 stopni względem podstawy, dla działa fazowego od -20 do +45 stopni);
* nie jest konieczne dokładne ustawienie bota na wprost celu (cel nie jest punktem geometrycznym tylko bryłą, dokładność 2 stopni w poziomie i pionie powinna wystarczyć)
* działo nie jest botem (position.z to wysokość podstawy bota nad poziomem morza; działo jest zamontowane 1,5-2 metrów wyżej, 1-2 metry do przodu od środka podstawy, FIXME!);
* nachylenie bota (często bot jest przechylony, np. spoczywa na nachylonym terenie, więc jego podstawa jest nachylona pod pewnym kątem; tym samym lufa ustawiona w położeniu "zero stopni" nie jest wycelowana poziomo. Ponadto, nawet kiedy bot jest skierowany w poziomie w kierunku celu, to jego przechylenie na bok (lewa/prawa) powoduje, że znajdująca się ponad podstawą lufa nie jest skierowana dokładnie w kierunku celu, ale nieco w bok);
* widoczność celu (co jeśli cel będzie w odpowiedniej odległości, ale za górką?);
* ruch celu (należy brać poprawkę na zmianę położenia celu: w momencie, kiedy pocisk doleci na odpowiednią odległość, ruchomy cel już nie znajduje się w miejscu, w którym był w momencie celowania)
* linia prosta to tylko przybliżenie toru lotu pocisku (szczególnie dla działa fazowego, które może strzelać pod kątem 45 stopni; wtedy dokładniejszym modelem ruchu pocisku jest rzut ukośny, w jednolitym polu grawitacyjnym, którego torem jest parabola).

Jeśli kogoś interesuje rozwinięcie któregoś z tych tematów, niech śmiało pyta.

[adiblol]

przechylenie na bok lewa/prawa mnie interesuje. Byłbym wdzięczny za przedstawienie sposobu obliczania.

[pipok]

Ech! Niestety, z tym jest najwięcej rysowania, więc sporo czasu...

Przechylenie (roll)
Zacznijmy od sytuacji już rozwiązanej: bot jest skierowany na wprost celu. Znamy odległość w pionie oraz w poziomie pomiędzy botem a celem, policzyliśmy kąt, pod jakim należy podnieść lufę, żeby cel znalazł się na przedłużeniu jej osi. Tym razem spójrzmy na schemat tej sytuacji nie z boku, lecz zza bota, z tyłu (lewa część rysunku). W rzucie na płaszczyznę rysunku cel leży na pionowej osi przechodzącej przez podstawę bota, na wysokości H.

Wyobraźmy sobie teraz, że bot się przechylił na prawy bok. Wówczas cel znajdzie się po lewej stronie osi lufy i nieco niżej niż poprzednio (prawa część rysunku). Bez zmiany układu odniesienia, związanego z poziomą płaszczyzną powierzchni morza, możemy wyliczyć nową wysokość celu względem płaszczyzny podstawy bota oraz odchylenie w poziomie. Kąt beta to roll, kąt przechylenia bota.

Kod:

H1 = H*cos(beta) Y1 = H*sin(beta)

Dla wygody dalszych kroków zmieńmy teraz układ odniesienia, tak żeby oś pionowa znowu pokrywała się z pionowa osią bota (zob. lewa część rysunku poniżej):

Ponieważ wysokość celu względem bota uległa zmianie i wynosi teraz H' zamiast H, powinniśmy policzyć nowy kąt pionowy między botem a celem (prawa część rysunku, kąt gamma), czyli pożądane nachylenie lufy. Odległość D pomiędzy botem a celem pokazaliśmy już na szkicu zamieszczonym w pierwszej notce, omawiającej najprostszy przypadek, kiedy płaszczyzna podstawy bota jest równoległa do płaszczyzny powierzchni morza. Ponieważ bot się tylko obrócił, odległość D nie uległa zmianie, na podstawie naszego pierwszego szkicu (patrz wyżej, 9 lipca 2009, 9:33) mamy:

Kod:

H/D = sin(alfa) H = D*sin(alfa)

stąd

Kod:

H1 = H*cos(beta) = D*sin(alfa)*cos(beta)

korzystając z rysunku pokazującego kąt gamma:

Kod:

sin(gamma) = H1/D sin(gamma) = D*sin(alfa)*cos(beta) / D

Ostatecznie:

Kod:

gamma = asin( sin(alfa)*cos(beta) )

Jak dużo zmienia ta poprawka, przyjęcie kąta nachylenia lufy gamma zamiast kąta alfa, jak poprzednio? Jeśli przy wypoziomowanym bocie cel był widoczny pod kątem 20 stopni, to po obróceniu się bota o 20 stopni na bok cel jest widoczny pod kątem 18,7 stopni. Co przy odległości do celu równej 40 metrów daje metr różnicy w pionie.

Pozostaje nam poziome odchylenie celu od osi lufy. Niestety, w skrypcie nie możemy obracać lufy w płaszczyźnie pionowej względem podstawy, co pozwoliłoby na zniwelowanie odchylenia pojawiającego się w postaci niezerowej wartości Y'. Trzeba będzie obrócić całego bota.

potrzebujemy kąta obrotu w płaszczyźnie podstawy bota.
Z rysunku mamy:

Kod:

X/S = cos(epsilon) S/D = cos(gamma) S = D*cos(gamma)

Skąd wziąć brakującą do wyliczenia kąta epsilon długość X? Wystarczy na rysunku umieścić trójkąt o bokach D, L, H, którym zajmowaliśmy się poprzednio (patrz wyżej, 9 lipca 2009, 9:33), zanim bot przechylił się na bok:

X to po prostu dobrze nam znane L - to jest ten sam odcinek. Mamy zatem:

Kod:

L/D = cos(alfa) L = D*cos(alfa)

skąd:

Kod:

cos(epsilon) = X/S = ( D*cos(alfa) ) / ( D*cos(gamma) ) cos(epsilon) = cos(alfa)/cos(gamma) epsilon = acos ( cos(alfa)/cos(gamma) )

Mamy więc rozwiązanie? Wystarczy obrócić bota o kąt epsilon? Niestety, niezupełnie. Drobna zagwozdka polega na tym, że epsilon to pożądany kąt obrotu w płaszczyźnie podstawy bota, przechylonej o kąt beta w stosunku do poziomej powierzchni morza. Służąca do obracania bota funkcja turn() obraca bota o zadany kąt, ale... mierzony na poziomej płaszczyźnie morza.
Do rozwiązania tego posłużymy się rysunkiem w układzie związanym z poziomą powierzchnią. Kąt epsilon został znacznie powiększony, dla poprawienia czytelności rysunku:

Kod:

Z1/Y1 = sin(beta) Y1/S = sin(epsilon) Z1/S = sin(fi)

stąd:

Kod:

sin(fi) = ( Y1*sin(beta) ) / ( Y1/sin(epsilon) ) sin(fi) = sin(beta)*sin(epsilon) fi = asin( sin(beta)*sin(epsilon) )

Kod:

R/S = cos(fi) L/S = cos(epsilon) L/R = cos(delta)

stąd:

Kod:

cos(delta) = (S*cos(epsilon) ) / ( S*(cos(fi) ) cods(delta) = cos(epsilon)/cos(fi) delta = acos( cos(epsilon)/cos(fi) )

Otrzymany kąt delta jest poszukiwanym przaz nas rzutem kąta epsilon, leżącego w płaszczyźnie podstawy bota, na płaszczyznę poziomą.

Kod wynikowy
Fragment kodu obsługującego poprzeczne przechylenie bota wygląda zatem tak (z poprawkami wynikającymi z własności funkcji cos()):

Kod:

wrog=radar(AlienAnt); cel=wrog.position;    // punkt, do ktorego celujemy turn(direction(cel)); // obroc w kierunku celu alfa = atan( (cel.z - position.z) / distance2d(position, cel) ); // kat pionowy na cel, wstepnie beta = roll;   // kąt przechylenia bota na bok (lewa/prawa) gamma = asin( sin(alfa)*cos(beta) ); // skorygowany kat pionowy na cel e = acos ( cos(alfa)/cos(gamma) ); if (alfa<0)  e = -e; f = asin( sin(beta)*sin(epsilon) ); delta=0; if (cos(fi)!=0)   delta = acos( cos(epsilon)/cos(fi) ); if (f<0)  delta = -delta; turn(delta); aim(gamma); // jeśli udało się podnieść lufę o zadany kąt, to bot jest już gotowy do strzału

Ważne
Obliczenia przeprowadziliśmy przy dwóch bardzo istotnych założeniach:
* wartość przechylenia roll wzięta w sytuacji, kiedy bot jest obrócony w kierunku celu, tj. gdy direction(cel)==0.
* ignorujemy pochylenie bota w osi przód-tył względem poziomej płaszczyzny, tj. zakładamy, że pitch==0.

[Abadon]

Brawo pipok, masz profesjonalne podejście do sprawy. Mam pytanie czy czasem nie uczyłeś się z jakiegoś podręcznika, bo jakoś znajomo wygląda?

P.S Te rysunki robiłeś za pomcą programu "wykresik"?

[pipok]

[Bartek c++]

yyyyyyyyyyyyyyyyyyyyyyyyyyyyy! co tu pisze do diabła!!!!!!!!!!!!!


//jest napisane, a nie "co tu pisze"! - Abadon

[Schocker]

@Bartek c++: Nie dziwię się, że nie rozumiesz, ale mogłeś nie pisać takiego postu, tylko poprosić o wytłumaczenie. Choć nie jestem pewien, czy da się to łatwiej opisać, to są dość skomplikowane rzeczy, przynajmniej dla kogoś w Twoim wieku.
@Pipok: Mnie natomiast interesuje sprawa widoczności celu. Mógłbyś o niej dokładniej napisać? ^^;

[adiblol]

Widoczność celu - trzeba wyliczyć punkty na linii działo-wróg i funkcją topo sprawdzać czy nie zasłaniają one linii strzału; przyda się interpolacja.
Zgadłem?

[shoter]

[karpol]

Ja też 11, a jakoś rozumiem nawet coś.

[pipok]

Kierunek (direction), przechylenie (roll) i pochylenie (pitch)
Ogólniejszym przypadkiem jest występujące równoczesnie przechylenie bota na bok (roll) i pochylenie w osi przód-tył (pitch). Po prostu podstawa bota jest na ukos względem poziomej powierzchni morza. Jeśli do tego zażyczymy sobie, żeby obrót bota w kierunku celu był wykonywany raz (por. poprzednie rozwiązanie, dla samego przechylenia), to otrzymamy następujący fragment programu:

Kod:

wrog=radar(AlienAnt); cel=wrog.position; azymut = direction(cel); alfa = atan( (cel.z-position.z)/distance2d(position, cel) ); // -- poprawka na nachylenie terenu pitchK = pitch*cos(azymut) - roll*sin(azymut); rollK  = roll*cos(azymut)  + pitch*sin(azymut); alfa = alfa - pitchK; beta = rollK; gamma = asin( sin(alfa)*cos(beta) ); e = acos ( cos(alfa)/cos(gamma) ); if (alfa<0)  e = -e; f = asin( sin(beta)*sin(epsilon) ); delta=0; if (cos(fi)!=0)   delta = acos( cos(epsilon)/cos(fi) ); if (f<0)  delta = -delta; azymut = azymut + delta; alfa=gama; // -- koniec poprawki turn(azymut); aim(alfa); if (alfa > -20) && (alfa < 45) {  // ograniczenia kąta obrotu lufy dla działa fazowego   fire(0.1); }

Jak widać, różni się od kodu dla samego przechylenia roll zaledwie kilkoma istotnymi linijkami. Najważniejsze to:

Kod:

pitchK = pitch*cos(azymut) - roll*sin(azymut); rollK  = roll*cos(azymut)  + pitch*sin(azymut); alfa = alfa - pitchK;

Pierwsze dwie linijki to przeliczenie kątów pochylenia i przechylenia na takie, jakie będą po obrocie bota w kierunku celu. Zmienią się, bo jeśli spoczywający na ziemi bot jest przechylony np. do góry i na lewy bok (leży na zboczu, skierowany w górę), a cel jest dokładnie za nim, to po obrocie o 180 stopni będzie przechylony w dół i na prawy bok (leży na zboczu, skierowany w dół).
Trzecia linijka to pomniejszenie wysokości kątowej celu o kąt pochylenia bota w osi przód-tył.
Na razie nie dokładam rysunków ani sposobu uzyskania wzorów z tych linijek. Chyba że ktoś będzie naprawdę zainteresowany

---------------------------------------------------------------------------------------------------
EDIT: o widoczności
Zgadłeś, adiblol Właściwie, nie da się inaczej rozwiązać, bo bot nie ma do dyspozycji modelu całego terenu, w postaci jakiejś siatki wielokątów. Może tylko badać pojedyncze punkty.
---------------------------------------------------------------------------------------------------

[pipok]

Widoczność
Mimo że cel jest w zasięgu strzału bota, to może być niedostępny dla pocisku. Taka sytuacja zachodzi, kiedy na linii strzału znajduje się wzniesienie terenu, oddzielające bota od celu. Kiedy zakładamy płaski tor pocisku (odcinek linii prostej), wówczas równie dobrze możemy mówić o problemie widoczności celu. Jak sprawdzić, czy cel jest widoczny?

Posłużymy się szkicem podobnym do pokazanego w części ogólnej:

Jeżeli linia łącząca bota i cel przecina powierzchnię terenu, to mamy do czynienia z brakiem widoczności celu. Niestety, nasz bot nie dysponuje wzorem opisującym teren, może tylko badać pojedyncze punkty przestrzeni. Weźmy kilka punktów leżących na odcinku łączącym pozycję bota z celem. Jeśli chociaż jeden z nich leży poniżej poziomu gruntu, to znaczy, że część toru pocisku przechodzi pod ziemią. Wtedy cel nie jest widoczny, lecz zasłonięty nierównością terenu - pocisk trafi w grunt i nie dotrze do celu.

W jaki sposób dowiedzieć się, czy dany punkt leży na powierzchni terenu, ponad nią czy pod nią? W języku programowania botów istnieje funkcja topo(), zwracająca dla podanej pozycji wysokość gruntu ponad poziomem morza.

Jeżeli współrzędna z danego punktu (wysokość ponad poziomem morza) jest większa niż wysokość gruntu nad poziomem morza w tym miejscu, to punkt leży ponad terenem. Jeśli mniejsza, to pod powierzchnią terenu:

Kod:

if ( pkt.z < topo(pkt) ) // punkt pod powierzchnią terenu

Sprawdzimy ten warunek dla każdego z punktów umieszczonych przez nas na linii bot-cel. Do tego potrzebujemy znać ich położenie, czyli wyznaczyć współrzędne pierwszego punktu, drugiego, trzeciego...
Odległość pomiędzy botem a celem wyznaczamy korzystając z gotowej, dostępnej w języku programowania botów funkcji distance, podającej odległość pomiędzy dwoma punktami w przestrzeni:

Kod:

D = distance(position, cel);

Różnica wysokości pozycji bota i celu to różnica współrzędnych z (wysokości ponad poziomem morza) obu punktów

Kod:

H = cel.z -  position.z;

Powiedzmy, że odległość D pomiędzy botem a celem wynosi 30 metrów, a badane punkty rozmieściliśmy jak na rysunku, dzieląc odcinek na 5 równych części, po 6 metrów każda. Pierwszy punkt leży w 1/5 całkowitej odległości między celem a botem, a więc znajduje się wyżej od bota o 1/5 całkowitej różnicy wysokości między celem a botem. Jeżeli różnica wysokości H wynosi 10 metrów, to pierwszy punkt znajduje się H/5 = 2 metry wyżej niż bot. Jego wysokość nad powiomem morza wynosi więc:

Kod:

pkt1.z = position.z + (H/5);

Dla drugiego punktu:

Kod:

pkt2.z = position.z + 2*(H/5);

dla trzeciego:

Kod:

pkt3.z = position.z + 3*(H/5);

Podobnie zachodzi dla pozostałych współrzędnych.

Możemy już napisać kawałek kodu funkcji badającej widoczność. Jako parametr pobiera punkt, którego widoczność sprawdzamy; jako wynik zwraca wartośc logiczną - czy punkt jest widoczny.

Kod:

public boolean object::widocznosc(point cel) { [...]    // petla po kolejnych punktach, az do osiagniecia celu    // odleglosc D jest podzielona na 5 rownych czesci    for (int i=D/5; i < D; i=i+D/5)    {       // wspolrzedne badanego punktu       pkt.x = position.x + (i * (cel.x - position.x) / 5);       pkt.y = position.y + (i * (cel.y - position.y) / 5);       pkt.z = position.z + (i * (cel.z - position.z) / 5);       // sprawdzenie czy punkt lezy nad czy pod gruntem       if (pkt.z < topo(pkt)) return false;    }    return true; }

Dlaczego dzielić odległość od celu akurat na 5 części? Możemy podzielić na 10 lub 20. Możemy też podzielić odległość D na odcinki metrowej długości, wszystko jedno, ile ich będzie. Właśnie: ile będzie takich odcinków? Jeśli D=25, to 25, jeśli D=40, to 40, oczywiście. W takim razie

Kod:

z1m = H/D = (cel.z-position.z)/D

jest przyrostem wysokości dla odcinka o długości 1 metra. A jeżeli odległość D podzielimy na odcinki 3-metrowe? Wtedy przyrost wysokości będzie 3 razy większy

Kod:

z3m = 3*z1m = 3 * (cel.z-position.z)/D

Przyjmijmy ogólniej, że punkty rozstawiamy co odc metrów, tyle ile zechcemy. Tę liczbę będziemy podawać jako parametr funkcji:

Kod:

// 'odc' - odleglosc pomiędzy kolejnymi sprawdzanymi punktami na linii bot-cel public boolean object::widocznosc(point cel, int odc) {    point pkt;    float D;    float x1m, y1m, z1m;        D = distance(position, cel);    // zmiana współrzędnych na kazdym odcinku    x1m = (cel.x - position.x) / D;    y1m = (cel.y - position.y) / D;    z1m = (cel.z - position.z) / D;          // petla po kolejnych punktach, az do osiagniecia celu    // punkty dziela odleglosc D na odcinki o dlugosciach    // 'odc' metrow kazdy    for (int i=odc; i < D; i=i+odc)    {       // wspolrzedne badanego punktu       pkt.x = position.x + (i * x1m);       pkt.y = position.y + (i * y1m);       pkt.z = position.z + (i * z1m);       // sprawdzenie czy punkt lezy ponizej poziomu gruntu       if (pkt.z < topo(pkt)) return false;    }    return true; }

Im odc jest mniejsze, tym dokładniejsze będzie sprawdzenie. Dla punktów rozstawionych co 10 metrów wynik "Ok, cel widoczny" może być niezgodny z rzeczywistością. Z drugiej strony, do sprawdzenia punktów w odstępach 1 metra potrzeba więcej obliczeń ogółem, bo po prostu punktów jest więcej. Jeżeli dodatkowo analizowana odległość między botem a celem jest bardzo duża, może się okazać, że wywołanie funkcji spowoduje spowolnienie programu. Możemy wówczas zmniejszyć parametr do 5 metrów, ewentualnie 3 metrów lub użyć funkcji ipf(), zwiększającej szybkość, z jaką bot interpretuje kod programu.

[colobotwymiiata]

Jesteś wielki

[Reaper]

[FE4R]

Ja natomiast stworzyłem taki oto program:

Kod:

extern void object::Adjust() { while(true) { object x; float h, a, c, n; x = radar(Me); h = x.position.z - topo(x.position); a = distance2d(x.position, position); c = a/h; c = tan(n); aim(n); } }

Jego funkcją z założenia było, aby działo organiczne dostosowywało swoją lufę do wysokości i odległości od celu, a w zasięgu 40 metrów po prostu do niego wypaliło cały czas sprawdzając czy poziom lufy jest zgodny. Jednak zmienna nie została zadeklarowana, przynajmniej tak mi mówi komunikat w grze. Nie wiem jaki jest błąd. W teorii to równanie:

c = a/h;
c=tan(n);
aim(n);

jest poprawne, a jednak - nie działa.

Jakieś propozycje?