NoLiFeR

Skoro masz dostęp do bazy to wystarczyło sobie dodać konto bezpośrednio w bazie.

Zgodnie z licencja pawna kto chce i kto ma kod źródłowy może go opublikować i na to nic nie poradzicie, dlatego albo sma daje się zaufanym klientom albo wcale, więc teraz nie ma co płakać i dziwić się, że ktoś to udostępnia.

http://translate.google.com/

Heh, speedkil dobry bit

Mam model jedynie kurczaka (nie kaczki) z mapy cs_italy, a muzyki nie zrobię (chyba że mi dasz gotową)

Łap muzykę :

Przecież Pukawka twierdzi "że rozwiązują problemy razem z klientem i pomagają w konfiguracji serwera itp.".

Po zakrzywieniu toru lotu dajesz to samo co po wystrzeleniu ale juz z nowymi parametrami lotu wiec to zaden problem.

Ja widzę różne opcje:

- Zwiększ wymiary boxu strzały tak aby sięgały 30 unitów. Wtedy touchem wykryjesz. Opcja o tyle niedokładna, że zależnie od kąta nachylenia itd box bytu będzie większy także w niepotrzebnych wymiarach przez co może przelatywać obok func_breakable i go zniszczyć.

- Licz w częstym thinku tego bytu odległość od wszystkich func_breakable na mapie i jeśli jest odpowiednio mała to wywołuj obrażenia na func_breakable. Tutaj możesz się bawić do woli, zaleznie od kątu nachylenia liczysz odległość tylko w jednym kierunku, w którym leci strzała, w zasadzie ogranicza Cię tylko wiedza z matmy a dokładniej geometrii no i optymalność.

- Ostatni wydaje mi się najsensowniejszy. Nie wiem jaki movetype ma Twoja strzała, ale zakładam, że nie leci po linii prostej tylko działa nań grawitacja. Jeśli nie to nawet prościej będzie.

---Jeśli leci prosto to puszczasz traceline w kierunku gdzie leci. Jak traceline przetnie funca to Tworzysz nextthink na przybliżony czas kiedy doleci. Wzór na prędkość/drogę/czas znasz Wtedy w tym thinku sprawdzasz czy jest odpowiednio blisko żeby rozwalić 'kratkę', jeśli nie to tworzysz nextthink na bardzo krótki czas i sprawdzasz ponownie i tak do skutku. Jeśli na drodze nie ma żadnego func_breakable to nie ustawiasz thinka do sprawdzenia, bo i po co. 

---Jeśli leci z lekką grawitacją to już trochę więcej zabawy, ale dalej da się przewidzieć gdzie poleci. Nie wiem jak to dokładnie zrobić, ale widziałem kiedys plugin DarkGL, który malował łukowatą linię wskazującą gdzie poleci granat po rzucie. Może tak znajdziesz sposób jak przewidzieć drogę strzały.

I z czym ona jest unikatowa? Z CZYM? to zwykla sklejka.

for(new i=0;i<3;i++)
		vecVelocity[i] /= iCount

nie dziel vecVelocity[2] bo ono odpowiada za prędkość w pionie, a tej niepotrzeba zmniejszać jeśli trzymasz dwa przyciski

Najpierw to zrób prościej bo obecnie wygląda to strasznie dopiero wtedy przystąpimy do poprawy

Prawdę mówiąc jest tu nasrane dużo kodu i ciężko z niego jasno wywnioskować co ma on dokładnie robić i w jakich okolicznościach.

Kilka wskazówek jak ułatwić innym a także sobie w przyszłości odszyfrowanie kodu (dziś ogarniasz, bo dopiero co go pisałeś, ale za kilka tygodni/miesięcy jak zapragniesz coś zmienić to się pogubisz):

-nazywaj zmienne zgodnie z ich przeznaczeniem-używaj pełnych nazw a nie skrótów, które tylko Ty rozumiesz, nawet jeśli nazwa będzie przez to dłuższa.

-używaj przedrostków sugerujących typ zmiennej w jej nazwie (dużo lepiej czyta się vecSpeed, iCount,szClass niż speed, count,class)

-! używaj komentarzy jak najwięcej, na prawdę dużo można po nich wywnioskować

-podajesz tylko jedną funkcję, która nie wiadomo kiedy się wykonuje i używasz w niej zmiennych, które nie wiadomo co przechowują, można jedynie wywnioskować, że skoro ich deklaracji nie ma wewnątrz to są globalne, ale gdzie i kiedy są jeszcze modyfikowane to nie wiadomo.

 

 

Konicznie opisz jaki player i jak ma sterować no i czym oczywiście. Podaj szczegóły dotyczące bytu sterowanego, jak ma wyglądać i jak się poruszać, jakiej jest klasy, po prostu co możesz. No i popraw ten kod bo faktycznie nie jest dobrze...

Co dokładnie się dzieje? Nie mam jak przetestować moich przypuszczeń, ale tak:

 

-Zakładam, że funkcja ta jest odpalana w prethinku

-Zmienna iCount to wielka zagadka jeżeli funkcja odpalana jest w prethinku tak jak zakladam to wartosc iCount może wynosić 0,1,2,3 lub 4 zależnie ile przycisków trzymasz w danej klatce.

Jaki sens ma zatem dzielenie vectora przez 1,2,3 lub 4? (przy zerze funkcja zostanie wcześniej przerwana i słusznie, bo przez 0 się nie dzieli)

for(new i=0;i<3;i++)
		vecVelocity[i] /= iCount

Zakładam, że chciałeś jej użyć do spokojnego przyspieszania, ale jest ona deklarowana na nowo za każdym wywołaniem funkcji więc nigdy nie pójdzie wyżej.

 

 

Zobacz jak to zadziała:

public poruszanie(ent, id, Float:Angles[3], buttons) {
	new Float:vecVelocity[3];
	//pev(ent, pev_velocity, vecVelocity)
//	new Float:f_OldFallVelocity = vecVelocity[2]
		
	static  iCount[32] ; 
	new iTrzymaRuch=0;
	new Float:Temp[3];
	// W && !S
	if(buttons & IN_FORWARD && !(buttons & IN_BACK)) {
		angle_vector (Angles, ANGLEVECTOR_FORWARD, Temp)
		if(iCount[id]<250)	iCount[id]++
		iTrzymaRuch=1;
	}
	// S && !W
	else if(buttons & IN_BACK && !(buttons & IN_FORWARD)) {
		angle_vector (Angles, ANGLEVECTOR_FORWARD, Temp)
		xs_vec_neg(Temp,Temp)
		if(iCount[id]<250)	iCount[id]++
		iTrzymaRuch=1;
	}
	
	// D && !A
	if(buttons & IN_LEFT && !(buttons & IN_RIGHT)) {
		angle_vector (Angles, ANGLEVECTOR_RIGHT,Temp)
		xs_vec_neg(Temp,Temp)
		if(iCount[id]<250)	iCount[id]++
		iTrzymaRuch=1;
	}
	// A && !D
	else if(buttons & IN_RIGHT && !(buttons & IN_LEFT)) {
		angle_vector (Angles, ANGLEVECTOR_RIGHT,Temp)
		if(iCount[id]<250)	iCount[id]++
		iTrzymaRuch=1;
	}
	
	if(iTrzymaRuch==0)
	{
		iCount[id]=0;
		return;
	}
		
	xs_vec_mul_scalar(Temp, float(iCount[id]), Temp);
	for(new i=0;i<3;i++)
		vecVelocity[i] += Temp[i]
	
		
	//vecVelocity[2] = f_OldFallVelocity
	
	set_pev(ent,pev_velocity,vecVelocity)
}

 

Już kilka artykułów o tym istnieje, jednak żadnen nie opisuje tego dokładniej. Istnieje również ładny artykuł na wikibooks, będący częścią książki o języku C (C/Operatory - Wikibooks, biblioteka wolnych podręczników) jednak opisuje on niektóre kwestie dość zawile i jest o języku C, a w PAWNie jest kilka drobnych różnic (m.in w rzutowaniu itp)
 
Wstęp
 
Ogólnie operatory możemy podzielić na 3 kategorie: dwuargumentowe, jednoargumentowe i jeszcze jeden, samotny w swojej grupie operator wyrażenia warunkowego ( ? : ) który posiada 3 argumenty.
 
Operatory dwuargumentowe przyjmują 2 argumenty, rozdzielone właśnie tym operatorem. Argumenty nazywamy odpowiednio lewym i prawym.
 
Operatory jednoargumentowe przyjmują tylko jeden argument, który powinien być określony z lewej lub z prawej strony operatora (w zależności od operatora i jego użycia).
 
Operator przypisania
 
Operator przypisania, czyli operator = służy do umieszczenia wartości znajdującej się z prawej strony w zmiennej po lewej stronie. Po prawej może znajdować się dowolne wyrażenie, po lewej musi znajdować się zmienna.
 

a = 10  // przypisze wartość 10 do zmiennej a

Umieszczenie czegokolwiek innego po jego lewej stronie poskutkuje pięknym błędem kompilacji.
 

10 = a // zwróci błąd, nie możemy przecież nic przypisać do 10, nie jest zmienną!
10 = 12 // również zwróci błąd
10 = 10 // to też jest błąd, nie ważne że 10 jest równe 10, to nie jest operator porównania

Co ciekawe, operator przypisania ZWRACA wartość. Wartością tą jest wartość prawego wyrażenia, dzięki temu możemy takiego operatora użyć kilkukrotnie w 1 instrukcji:
 

a=b=c=12 // zmiennej c przypisze wartość 12, następnie zrobi to samo dla wartości b oraz a

 
Dzięki temu możemy użyć takiego operatora w warunku if:
 

if ( x = funkcja(y) )

Wiele osób pewnie pomyśli, że powyższy kod porówna x z wartością zwróconą przez funkcję. Otóż nie zrobi tego! Przypisze on do zmiennej x wartość zwróconą przez funkcję, a następnie tą samą wartość zwróci. Tak więc jeśli funkcja zwróci true, kod wewnątrz if się wykona, jeśli zwróci false, kod się nie wykona. Nie jest ważne co do tej pory siedziało w zmiennej x, na dodatek zostanie to zastąpione nową wartością!
 
Bystre oko zauważy, że kompilator AMXX zwróci nam warning przy kompilacji tej linii. Aby kompilator uciszyć, wystarczy objąć warunek dodatkowymi nawiasami:
 

if (( x = funkcja(y) ))

Nie zmieni to działania warunku, ale poinformuje kompilator, że WIEMY co robimy i nie pomyliliśmy się używając = zamiast == w tym miejscu.
 
Operatory arytmetyczne
 
Operatory arytmetyczne wykonują proste działania arytmetyczne i zwracają ich wynik. Wszystkie operatory arytmetyczne są dwuargumentowe i zaliczamy do nich +, -, *, / oraz %. Wykonują one po kolei: dodawanie, odejmowanie, mnożenie, dzielenie (zwrócenie wyniku z dzielenia), dzielenie (zwrócenie reszty z dzielenia). Przykłady:
 
 

10 + 20 // 30
20 - 2 // 18
14 * 3 // 42
12 / 2 // 6
13 / 2 // również 6 !
13.0 / 2 // 6.5
13 % 2 // 1

 
Dodatkowemu wyjaśnieniu podlegają operatory dzielenia. Pierwszy z nich dokona dzielenia całkowitego (tj zaokrągli wynik z dzielenia do jedności w dół) jeśli po jego obu stronach znajdą się liczby typu całkowitego. Dokona jednak dokładnego dzielenia, gdy choć z jednej strony znajdzie się liczba zmiennoprzecinkowa. Drugi z operatorów dokona zawsze dzielenia całkowitego i zwróci jego resztę.
 
Operatory znaku liczby
 
Są to operatory - i + dla których podany został tylko 1 argument, po prawej stronie. Skutkiem jest zachowanie (dla +) lub zmiana na przeciwny (dla -) znak liczby. Wyobrazić sobie można to tak, jakby po lewej stronie wirtualnie stało zawsze 0
 
Operatory te można rozróżnić tylko, gdy po lewej stronie nie znajduje się nic, znajduje się inny operator lub znajduje się nawias.
 
Operatory bitowe
 
Istnieje 7 operatorów bitowych, jeden jednoargumentowy i sześć dwuargumentoych.
 
Operatorem jednoargumentowym jest ~ czyli negacja bitowa. Przyjmuje on argument po swojej PRAWEJ stronie:
 

~14 // dobrze
14~ // żle, argument musi być po prawej!

 
Operator zwraca negację bitową podanego argumentu.
 
Operatorami dwuargumentowymi są operatory &, |, ^, <<, >> oraz >>>. Trzy pierwsze z nich dla podanych argumentów zwracają odpowiednio ich koniunkcję bitową (iloczyn bitowy), ich alternatywę bitową (suma bitowa) oraz ich alternatywę rozłączną (bitową różnicę symetryczną, XOR).
 
Pozostałe trzy dokonują przesunięcia bitowego. Argument po lewej stronie jest liczbą przesuwaną, a argument po prawej oznacza o ile bitów argument po lewej zostanie przesunięty. << dokonuje przesunięcia w lewo, >> w prawo arytmetycznie, a >>> w prawo logicznie.
 
Więcej o operatorach bitowych tutaj: Operacje bitowe
 
Operatory skróconego przypisania
 
Operator skróconego przypisania jest niczym innym, jak połączeniem operatora arytmetycznego lub bitowego z operatorem przypisania. Dla operatora •:
 

a •= 10

jest równoznaczne:
 

a = a • 10

Oczywiście operator • w języku pawn nie istnieje, należy go zastąpić dowolnym operatorem arytmetycznym lub bitowym.
 
Inaczej mówiąc: operator ten wykona działanie na argumencie lewym i prawym tak jakby to miało miejsce przy zwykłym operatorze arytmetycznym lub bitowym, jednak wynik tego działania zapisze również w lewym argumencie.
 
Oznacza to, że tak jak dla operatora przypisania, zwraca on wartość przypisywaną oraz wymaga by po jego lewej stronie znajdowała się zmienna.
 
Inkrementacja i dekrementacja
 
Są to operatory ++ oraz --, są operatorami jednoargumentowymi i występują w 2ch odmianach: post i pre. Postinkrementacja i postdekrementacja następują, gdy argument zostanie podany z lewej strony. Preinkrementacja i predekrementacja gdy zostanie podany z prawej strony. Przykłady:
 
 

i++ // postinkrementacja
++i // preinkrementacja
--i // predekrementacja
i-- // postdekrementacja

 
Operatory te zwiększają (inkrementacja) lub zmniejszają (dekrementacja) wartość liczby o 1. Jako, że zapisują one wynik w zmiennej podanej jako argument, przyjmują za argument WYŁĄCZNIE zmienne. Nie mogą być to liczby ani inne wyrażenia. Post od pre różni się zwracaną wartością. Postinkrementacja zwraca wartość przed wykonaniem działania, preinkrementacja wartość po wykonaniu działania. Preinkrementacja jest bezpośrednim odpowiednikiem zapisu:
 

i += 1

Postinkrementację można zapisać inaczej tylko jako funkcję:
 

postinkrementacja(&i) {
    new j = i;
    i += 1
    return j;
}

 
Operatory logiczne
 
Zanim o samych operatorach, trochę o samych stanach logicznych. W języku pawn istnieją 2 stany logiczne: prawda i fałsz, które są swoimi wzajemnymi przeciwieństwami. Fałszem jest wszystko o wartości zero, prawdą wszystko o wartości różnej od zera! To oznacza, że prawdą jest nie tylko 1, ale też 2, 10, 2000 a nawet liczby ujemne czyli -300 lub -1!
W związku z tym, że wartości dla prawdy jest de facto nieskończenie wiele (właściwie to skończenie, ale i tak mnóstwo), przyjęło się że każdy operator logiczny będzie zwracał 1 jako prawdę logiczną. Zważmy jednak na to, że nadal może on przyjąć dowolną wartość i jeśli jest ona różna od zera, potraktuje ją jako prawdę !!!
 
Operatorami logicznymi są: !, ==, !=, <, >, <=, >=, && oraz ||.
 
Pierwszy z nich, czyli ! jest operatorem jednoargumentowym i przyjmuje argument, tak jak operator negacji bitowej, po swojej prawej stronie. Zwraca on logiczne przeciwieństwo danego wyrażenia. Czyli jeśli jako argument dostanie prawdę, zwróci fałsz, jeśli fałsz to zwróci prawdę.
 
Reszta z nich przyjmuje 2 argumenty i możemy je podzielić na 2 kategorie: operatory porównania i operatory and i or.
 
Operatory porównania po prostu porównują 2 wartości ze sobą i zwracają prawdę lub fałsz jeśli ich wewnętrzny warunek został spełniony.
== sprawdzi czy wartości są równe
!= sprawdzi czy wartości są różne
> sprawdzi czy wartość po lewej jest większa od wartości po prawej
< sprawdzi czy wartość po lewej jest mniejsza od wartości po prawej
>= sprawdzi czy wartość po lewej jest większa lub równa wartości po prawej
<= sprawdzi czy wartość po lewej jest mniejsza lub równa wartości po prawej
 
Operator && jest to operator AND, sprawdza on czy zarówno po lewej jak i po prawej znajduje się prawda logiczna. Jest dość specyficznym operatorem, ponieważ najpierw sprawdzi (i jednocześnie wykona odpowiednie działania) czy po prawej jest prawda, a dopiero później po lewej. Jeśli po prawej znajdzie się fałsz, wszystko po jego lewej stronie NIE ZOSTANIE wykonane!
 
Oznacza to, że:
 

if (is_user_connected(id) && has_user_jetpack(id))

kod wewnątrz funkcji has_user_jetpack NIE ZOSTANIE NIGDY wykonany, jeśli gracz nie jest połączony do serwera!
 
Operator || jest operatorem OR, sprawdza on czy po lewej lub po prawej znajduje się prawda logiczna. On również zachowuje się specyficznie, gdyż nie wykona nigdy kodu po jego prawej jeśli po lewej znajduje się prawda.
 
Oznacza to, że:
 

if (has_user_jetpack(gracz1) || has_user_jetpack(gracz2))

sprawdzenie dla drugiego gracza czy posiada jetpack NIGDY SIĘ NIE WYKONA jeśli pierwszy gracz jetpack posiada.
 
Operator wyrażenia warunkowego
 
Operator ten przyjmuje 3 argumenty, pierwszy z nich wstawiamy przed znakiem zapytania, drugi pomiędzy znakiem zapytania, a dwukropkiem, a trzeci z nich za dwukropkiem.
 
Działanie operatora jest dość proste, jeśli 1 argument jest prawdą, zwróci on 2 argument, jeśli fałszem, zwróci 3 argument. Przykład:
 
 

is_user_connected(id)?"gracz jest na serwerze":"gracza nie ma na serwerze"

 
Nawiasy
 
Prócz tych wszystkich operatorów występują również nawiasy. Pierwszy z nich, czyli nawias okrągły () może służyć do 2ch rzeczy: może grupować (jak w matematyce) odpowiednie wyrażenia, zmieniając ich kolejność wykonywania oraz może być składnikiem definicji lub wywołania funkcji.
 
Drugi z nich, nawias kwadratowy [] służy do definiowania tablicy lub do wywoływania konkretnego elementu tej tablicy.
 
Priorytety i kolejność obliczeń
 
Każdy z operatorów posiada pewien priorytet, który determinuje kolejność w jakiej operatory zostaną wywołane jeśli znajdują się w 1 instrukcji. Dodatkowo każdy z operatorów posiada kierunek łączności, który determinuje w jakiej kolejności zostaną wykonane działania dla operatorów o tym samym priorytecie.
 
Priorytety od najwyższego do najniższego:

• Nawiasy
• wybór elementu tablicy, wywołanie funkcji, postinkrementacja, postdekrementacja 
• !, ~, + i - (jako znak liczby), preinkrementacja, predekrementacja
• *, /, %
• + i - (jako operatory arytmetyczne)
• <<, >>, >>>
• <, <=, >, >=
• == !=
• &
• ^
• |
• &&
• ||
• ?: (operator wyrażenia warunkowego)
• wszystkie operatory przypisania

Większość operatorów posiada łączność lewostronną. Wyjątkiem są operatory priorytetów 3, 14 i 15 które posiadają łączność prawostronną.