31 odpowiedzi w tym temacie

[grankee]

Testuje teraz własny kod i nie widze takich sytuacji jak opisane przez Ciebie. Przy wartosci kilku tysiecy wywalilo goscia na aim_map poza mape, dostal speeda jakby sie nawciągał. Przy 500 daje całkiem fajny odrzut. Jednak takie zachowanie ma miejsce jak strzelam do swojego przy wyłączonym friendlyfire, jak strzelam do wroga to faktycznie 3000.0 daje jakiś odrzut, ponieważ w silniku gry jest z góry narzucone spowolnienie gracza przy otrzymywaniu obrażeń. Jeśli lata krzywo tak jak na obrazku to zmien 

sv_maxvelocity 2000

które masz pewnie domyślnie na

sv_maxvelocity 10000

No i pzy podawaniu wartości dopisz .0 tzn

odrzut(kid,vid,2000.0)

Użytkownik grankee edytował ten post 26.12.2014 01:33

[grankee]

    new Float:przelicznik=value/odleglosc

Przy takim przeliczniku gdy gracze stoją tuż obok siebie to odrzut będzie tak duży, że roztrzaska nim o ścianę

 

Proponuję:

    new Float:przelicznik=(value+1)/odleglosc

to już wyeliminuje ten problem. Pamiętajmy też, że przy takim liczeniu odrzutu przy dużych odległościach różnica będzie bardzo znikoma.

 

Sory za post pod postem, ale niestety w edycji nie da sie zacytować

 

To nie tak, z założenia ma to liczyć "stosunek" odleglosci gracza od celu i przemnazac wszystkie trzy wektory przez ten stosunek, zeby zachowac kierunek ten sam, ale dostosowac sile odrzutu do podanej w argumencie.

Jeśli dodamy 1 do wartości argumentu to nie zauwazysz roznicy.

 

 

Mamy przykladowo różnice originow 10,20,30 to nam nada kierunek 10 unitow wzdluz osi x, 20 wzdluz y i 30 wzdluz z, ale takie liczby sa za male, zeby chociazby zobaczyc odrzut, nas interesuje  ten sam kierunek, ale wieksza sila wiec sprawdzamy odleglosc czyli dlugo linii prostej laczacej graczy

odleglosc=floatsqroot(Vec[0]*Vec[0]+Vec[1]*Vec[1]+Vec[2]*Vec[2])

przy podanych liczbach bedzie to okolo 37,4

i teraz 

new Float:przelicznik=value/odleglosc

przypuscmy, ze podalismy 3000.0 wiec przelicznik dostanie wartosc ok 80,2  - znaczy tyle razy trzeba powiekszyc wszystkie 3 kierunki, zeby zachowac ten sam tor lotu, ale wieksza sile

for(new i=0;i<3;i++)
		Vec[i]*=przelicznik

U mnie działa dobrze, tylko ważne jest to sv_maxvelocity 10000 albo wiecej, bo jesli velocity przekracza maxymalne to skrzywia tor lotu.

 

Inaczej moze rzucac jak ktos nie stoi na ziemi, ale nie mam mozliwosci tego przetestowac.

Użytkownik grankee edytował ten post 26.12.2014 01:52

[GwynBleidD]

Mamy przykladowo różnice originow 10,20,30 to nam nada kierunek 10 unitow wzdluz osi x, 20 wzdluz y i 30 wzdluz z, ale takie liczby sa za male, zeby chociazby zobaczyc odrzut, nas interesuje ten sam kierunek, ale wieksza sila wiec sprawdzamy odleglosc czyli dlugo linii prostej laczacej graczy

odleglosc=floatsqroot(Vec[0]*Vec[0]+Vec[1]*Vec[1]+Vec[2]*Vec[2])

przy podanych liczbach bedzie to okolo 37,4

i teraz

new Float:przelicznik=value/odleglosc

przypuscmy, ze podalismy 3000.0 wiec przelicznik dostanie wartosc ok 80,2 - znaczy tyle razy trzeba powiekszyc wszystkie 3 kierunki, zeby zachowac ten sam tor lotu, ale wieksza sile

for(new i=0;i<3;i++)
Vec[i]*=przelicznik

U mnie działa dobrze, tylko ważne jest to sv_maxvelocity 10000 albo wiecej, bo jesli velocity przekracza maxymalne to skrzywia tor lotu.



Inaczej moze rzucac jak ktos nie stoi na ziemi, ale nie mam mozliwosci tego przetestowac.

 

Załóżmy jednak taki przypadek, że gracze stoją blisko siebie, praktycznie się dotykają. Pewnie w silniku HLDS się taka sytuacja nie zdarzy, ale zakładamy że się zdarzy i odległość między graczami będzie wynosić 0.1 i jeśli podaliśmy 3000.0 to po podzieleniu otrzymujemy 30000.0 ! A przy odległości 0.0001 otrzymamy jeszcze więcej zer.

 

Ale niech pierwszy rzuci kamień ten, który jest bez winy też się pomyliłem, jedynka powinna być dodana do mianownika, a nie do licznika czyli:

    new Float:przelicznik=value/(odleglosc+1)

W ten sposób nigdy w mianowniku nie uzyskamy liczby z przedziału 0-1, więc nigdy nie uzyskamy przelicznika większego, niż nasze wcześniej założone value.

 

Oczywiście jak wcześniej wspomniałem, w HLDSie odległość pewnie nigdy nie będzie z przedziału 0-1 Ale warto się zabezpieczyć, bo ta jedynka nam nie zmieni prawie nic.

 

Dodatkowo mamy wyeliminowane dzielenie przez zero, bo odległość ujemna nie będzie nigdy.

[grankee]

To jest możliwe, np w trybie przenikania przez siebie graczy, ale czy wtedy da się strzelić w gracza w którym się jest? (bez skojarzeń)

 

Nie zapominajmy jednak o dalszej części kodu, mianowicie jeśli odległość będzie np. 0.01 to da nam przelicznik 300000 ok, ale dalej kazdy z trzech kierunkow jest przez ten przelicznik przemnazany i jesli odleglosc jest 0.01 to wszystkie trzy kierunki beda jeszcze mniejsze co w efekcie po przemnozeniu zniweluje nam te setki tysiecy

0.009 (bardzo prawdopodobna wartosc jednego z kierunkow) np po pomnozeniu przez nasz przelicznik 300000 da niecale 3000.

Użytkownik grankee edytował ten post 26.12.2014 02:25

[ogieR8]

Za chwilke to przetestuje, jednak najpierw muszę coś naprawić, bo jestem pedantem. może ktoś mi da wskazówkę, bo na ogół nie miałem potrzeby zaokrąglać ? warning 213: tag mismatch -> floatround(player_pkt[id]/20) oraz floatround(player_pkt[id] / 20, floatround_round), player_pkt przyjmuje wartości całkowite

 

#edit: o sv_maxvelocity nic nie wiem nawet 0 w configu o tym i na całym FTP (szukałem teraz po frazach)

[grankee]

domyslnie jest to 2000, wklep sobie do cfg 10000

floatround(float(player_pkt[id]/20))

[ogieR8]

Paradoks, zmieniać całkowitą na zmiennoprzecinkową, aby wrócić później proces Ale uporałem się zamieniając dzielenie przez całkowite na mnożenie przez zmiennoprzecinkowe (0-1).

 

Dobra, ustawienia załadowane, tylko nie zostało mi nic jak tylko.. iść spać, teraz widzę która godzina i nie znajdę testera, a boty ostatnio nic tylko mnie wkurzają, tym bardziej, że bot stop nie działa mi coś.. nawet na cheatach darka Tak więc jutro (dziś) jak wstanę i znajdę kogoś to zdam relację z kodu

[grankee]

potti?

[GwynBleidD]

Widzę jednego babola...

 

odrzut(attacker,victim,Float:value)
{
    new Float:vOrigin[3],Float:aOrigin[3];
    new Float:Vec[3];

    pev(attacker,pev_origin,aOrigin);
    pev(victim,pev_origin,vOrigin);
    for(new i=0;i<3;i++)
        Vec[i]=(vOrigin[i]-aOrigin[i])
    
    new Float:odleglosc
    odleglosc=floatsqroot(Vec[0]*Vec[0]+Vec[1]*Vec[1]+Vec[2]*Vec[2])
    
    new Float:przelicznik=value/odleglosc
    for(new i=0;i<3;i++)
        Vec[i]*=przelicznik
    set_pev(victim,pev_velocity,Vec);
}

 

linie 2006-2009 - tutaj obliczamy kierunek w jakim gracz powinien zostać odrzucony. Jednak takie obliczanie daje nam po prostu wektor będący odległością między graczem A, a graczem B. Wektor ten będzie więc tym dłuższy, im odległość większa.

 

Linie 2011-2012 - pięknie obliczona długoś wektora.

 

Linie 2014-2017 - tutaj przemnażamy nasz wektor przez przelicznik. Ten kod może również wyglądać tak:

    //
    for(new i=0;i<3;i++)
        Vec[i] *= value/odleglosc
    set_pev(victim,pev_velocity,Vec);

Teraz widać dokładnie co robimy z wektorem, tj mnożymy go przez jakąś stałą i dzielimy przez jego długość. Jeśli stałą pominiemy, to mamy samo dzielenie czyli otrzymujemy ni mniej, ni więcej jak wektor jednostkowy!

Wektor jednostkowy to nic innego, jak wektor o długości 1. Wektor jest skierowany w stronę, w którą chcemy ale ma ZAWSZE odległość 1!

Teraz weźmy spowrotem pod uwagę naszą stałą i wychodzi na to, że za każdym razem, niezależnie od odległości nasz wektor posiada długość równą value!

 

A chyba miał maleć wraz z odległością, prawda?

 

Więc skoro chcemy, aby malał z odległością to podzielmy go jeszcze raz przez odległość:

    new Float:przelicznik=value/odleglosc
    for(new i=0;i<3;i++)
        Vec[i]*=przelicznik/(odleglosc-1)
    set_pev(victim,pev_velocity,Vec);

 

Dlaczego -1? już to wyjaśniłem

[grankee]

linie 2006-2009 - tutaj obliczamy kierunek w jakim gracz powinien zostać odrzucony. Jednak takie obliczanie daje nam po prostu wektor będący odległością między graczem A, a graczem B. Wektor ten będzie więc tym dłuższy, im odległość większa.

kilka postów wyżej napisałem

z założenia ma to liczyć "stosunek" odleglosci gracza od celu i przemnazac wszystkie trzy wektory przez ten stosunek, zeby zachowac kierunek ten sam, ale dostosowac sile odrzutu do podanej w argumencie.

Właśnie to jest celem, zachować kierunek, ale dostosować siłę do tej, którą podasz w argumencie zatem nie jest to babol tylko umyślne działanie.

Linie 2011-2012 - pięknie obliczona długoś wektora.

Rozumiem, że ładniej będzie

new Float:odleglosc=floatsqroot(Vec[0]*Vec[0]+Vec[1]*Vec[1]+Vec[2]*Vec[2])

Linie 2014-2017 - tutaj przemnażamy nasz wektor przez przelicznik. Ten kod może również wyglądać tak:
    //
   

 for(new i=0;i<3;i++)
        Vec[i] *= value/odleglosc
    set_pev(victim,pev_velocity,Vec);

 

Czyli rozumiem, że bardziej optymalne jest trzykrotne dzielenie niż utworzenie zmiennej i jednokrotne liczenie? Pytam, bo nigdy nie zagłębiałem się na tyle, żeby to wiedzieć.

Teraz weźmy spowrotem pod uwagę naszą stałą i wychodzi na to, że za każdym razem, niezależnie od odległości nasz wektor posiada długość równą value!

Z takim zamiarem pisałem kod. Bez sensu bowiem byłoby,  gdyby odrzut był znikomy z bliska a olbrzymi z daleka.

Więc skoro chcemy, aby malał z odległością to podzielmy go jeszcze raz przez odległość:

Nie znalazłem takiej sugestii więc nie brałem takowej pod uwagę.

[GwynBleidD]

Czyli rozumiem, że bardziej optymalne jest trzykrotne dzielenie niż utworzenie zmiennej i jednokrotne liczenie? Pytam, bo nigdy nie zagłębiałem się na tyle, żeby to wiedzieć.

Nie twierdzę, że jest. Zmieniłem to tylko po to, by pokazać co ten fragment właściwie robi.

Rozumiem, że ładniej będzie

Akurat tutaj się niczego nie czepiam, to tylko analiza kodu krok po kroku

Z takim zamiarem pisałem kod. Bez sensu bowiem byłoby, gdyby odrzut był znikomy z bliska a olbrzymi z daleka.

Nie znalazłem takiej sugestii więc nie brałem takowej pod uwagę.

Myślałem, że założenie było takie, by odrzut malał z odległością.

[grankee]

Śmiałem się z siebie jak doszedłem do tego wzoru, że nie wpadłem na to od razu, że twierdzenie pitagorasa ma zastosowanie w dowolnej ilości wymiarów.

Najpierw liczyłem długość wektora w dwóch wymiarach, przyjąłem sobie dla ułatwienia i precyzji sprawdzania 3 w osi x oraz 4 w osi y czyli otrzymałem

floatsqroot(a*a+b*b )- długość wektora w dwóch wymiarach (x,y) następnie podniosłem to do kwadratu i wyciągnąłem pierwiastek czyli

floatsqroot(floatsqroot(a*a+b*b )*floatsqroot(a*a+b*b ))+c*c)

sprawdziłem poprawność podając sobie 12 jako wartość c, żeby długość dała okrągłe 13

i tak gapiłem się na ten wzór z pół minuty zanim klepnąłem się w czoło zauważająć, że podnoszę do kwadratu dwa takie same pierwiastki ...

Użytkownik grankee edytował ten post 27.12.2014 18:41