Szyfrant

Witajcie
 
Użytkownik georgeml ( pewnego zagranicznego forum ) naniósł poprawki oraz dodatki w pliku amxbans'a a dokładnie w pliku amxbans_core
 
Lista Zmian / Poprawek:

• Wymaga AMXModX w wersji 1.8.2 bądź wyższej
• Równoczesna współpraca users.ini oraz MySQL, zależny od ustawień cvaru amxbans_use_admins_file !
• Dodawanie adminów za pomocą komendy amx_addadmin ( users.ini oraz MySQL ), zapis zależny od ustawień cvaru amxbans_use_admins_file !
• Automatyczne usuwanie / wyłączanie admina gdy wygaśnie ( users.ini oraz MySQL )
• Gdy w users.ini ręcznie dokonamy zmiany długośći czasu aktywności admina, zostanie on automatycznie przeliczony.
• Praca z hasłami kodowanymi w md5 jak i "czystymi"
• Możliwość tworzenia zrzutu tabeli adminów z MySQL ( w przypadku padnięcia serwera MySQL, admini ładowani są z zrzutu [ tkz. dump ] )
• Możliwośc połączenia z VIP Menu, itp. pluginami, wymaga dopisania np. w sma pluginu bądź pliku amxmodx.inc ( w przypadku jak chcemy tego masowo używać a nie chce nam sie dopisywać w każdym pluginie tego ) odpowiedniego natywu
  

  native days_left_info( id );

• Możliwośc automatycznego czyszczenia MySQL oraz users.ini ( w przypadku users.ini po prostu komentuje admina aby był nie aktywny ) po określonym czasie od wygaśnięcia

Instrukcja dopisywania admina w users.ini

• Admin na czas nieokreślony ( Opcja #1 )
  • ​​Struktura 

  • "name|ip|steamid" "password" "access flags" "account flags"

  •   Przykładowy wpis 
    

    "STEAM_0:0:123456" "password" "abcdefghijklmnopqrstu" "ce"

• Admin na czas nieokreślony ( Opcja #2 )
  • ​​Struktura 

  • "name|ip|steamid" "password" "access flags" "account flags" "dni"

  • Przykładowy wpis 
    

    "STEAM_0:0:123456" "password" "abcdefghijklmnopqrstu" "ce" "0"

• Admin na czas określony
  • ​​Struktura 

  • "name|ip|steamid" "password" "access flags" "account flags" "dni" "data wygaśnięcia"

  • Przykładowy wpis 
    

    "STEAM_0:0:123456" "password" "abcdefghijklmnopqrstu" "ce" "0" "438510885"

• Automacznie wyłączony admin przez plugin po upływie jego ważności oznaczany w users.ini w taki sposób
  

  ;"STEAM_0:0:123456" password"" "abcdefghijklmnopqrstu" "ce" "0" "438510885"

  • Informacje dodatkowe!
    • Jeśli w miejscu dni oraz data wygaśnięcia będzię postawione "0" admin działa na czas nieokreślony
    • Jeśli w miejscu dni będzie ustawione "0" a w miejscu data wygaśnięcia będzię wartość >"0" admin działa na czas określony po upływie wyznaczonego terminu zostaje wyłączony
    • Date ważności admina podajemy w "Czasie Unixowym" tkz. czas POSIX. Polecam serwis Epoch Unix Time Stamp Converter aby przeliczyć "nasz czas" na "czas unix'owy".

Instrukcja używania komendy amx_addadmin

• Struktura komendy
  

  amx_addadmin "Nick lub SteamID" "hasło" "flagi dostępu" typ uwierzytelniania (nazwa lub parowe)" "Liczba dni"

• Przykład użycia
  • Nick
    

    amx_addadmin "Nick" "hasło" "abcdefghijklmnopqrstu" "a" "48"

  • SteamID
    

    amx_addadmin "STEAM_0:0:123456" "" "abcdefghijklmnopqrstu" "ce" "48"

  • SteamID + Hasło
    

    amx_addadmin "STEAM_0:0:123456" "hasło" "abcdefghijklmnopqrstu" "ca" "48"

 

Cvary Dodane / Zmodyfikowane

• amxbans_use_admins_file
  • ​0 - admini z MySQL
  • 1 - admini z users.ini
  • 2 - nie ładuje adminów ( lulz! )
  • 3 - admini z MySQL oraz users.ini
• amxbans_dump_sql
  • ​0 - nie tworzy zrzutu tabeli adminów na wypadek braku odpowiedzi serwera MySQL bądź jego padnięcia
  • 1 - tworzy zrzutu tabeli adminów na wypadek braku odpowiedzi serwera MySQL bądź jego padnięcia, przydatne gdy cvar amxbans_use_admins_file ma wartość 0, dla bezpieczęństwa i czystych sumieni przy używaniu wartości 3 w owym cvarze można tego też używać
• amxbans_expadmins_delete
  • ​0 - nie czyści wygasłych adminów
  • >0 - automatycznie czyści wygasłych adminów, po upłynięciu wpisanej wartości dni w tym cvarze
  • W przypadku AMXBansa połączonego z więcej niż jednym serwerem, na każdym serwerze wartość w tym cvarze musi być taka sama, w przeciwnym wypadku możemy narobić więcej szkód niż pożytku

 

 

Wyświetlanie pozostałego czasu do wygaśnięcia naszego admina w "AMX Mod X Menu"

 

Otwórz plik menufront.sma

Szukamy tekstu

new g_clientMenuPlugin[MAXMENUS][STRINGSIZE]

dopisujemy pod tym to ( jeśli nie dopisaliście sobie tego w pliku amxmodx.inc )

native days_left_info( id );

następnie szukamy funkcji 

displayMenu(id, pos)
{

w wyżej wymienionej funkcji, odnajdujemy ten kawałęk kodu

new start = pos * MENUITEMSPERPAGE

dopisujemy pod nim to

	/* Dni */
	new exp = days_left_info( id );
	new left[ 32 ];
	if ( exp == 0 )
		format( left, 31, "Nigdy!" );   
	else 
		num_to_str( exp, left, 31 );
	/* Dni */

kolejnym krokiem jest odnaleźienie tego kawałka kodu

g_coloredMenus ? "\yAMX Mod X Menu\R%d/%d^n\w^n" : "AMX Mod X Menu %d/%d^n^n" , pos + 1, (g_menusNumber / MENUITEMSPERPAGE) + (((g_menusNumber % MENUITEMSPERPAGE) > 0) ? 1 : 0))

i zastąpienie go tym kodem

	/* Zwykłe - Bez ważności admina */
	//g_coloredMenus ? "\yAMX Mod X Menu\R%d/%d^n\w^n" : "AMX Mod X Menu %d/%d^n^n" , pos + 1, (g_menusNumber / MENUITEMSPERPAGE) + (((g_menusNumber % MENUITEMSPERPAGE) > 0) ? 1 : 0))
	/* Zwykłe - Bez ważności admina */
	/* Nowe - z ważnością admina */
	g_coloredMenus ? "\yAMX Mod X Menu\R%d/%d^n^nAdmin wygasa za: %s dni.\w^n^n" : "AMX Mod X Menu %d/%d^n^nAdmin wygasa za: %s dni.^n^n" , pos + 1, (g_menusNumber / MENUITEMSPERPAGE) + (((g_menusNumber % MENUITEMSPERPAGE) > 0) ? 1 : 0), left)
	/* Nowe - z ważnością admina */

Zapisujemy, kompilujemy i podmieniamy plik na serwerze

 

W Załączniku dodałęm gotowy, zmodyfikowany menufront.sma z AMX Mod X 1.8.2

 

 

 

 amxbans_core.sma   29,64 KB  378 Ilość pobrań
  amxbans_core.amxx

 

 menufront.sma   14,1 KB  290 Ilość pobrań
  menufront.amxx

 

Wiadomość wygenerowana automatycznie


Ten temat został zamknięty przez moderatora.

Powód: Pomoc udzielona

Jeśli się z tym nie zgadzasz, raportuj ten post, a moderator lub administrator rozpatrzy go ponownie.


Z pozdrowieniami,
Zespół AMXX.PL

Szczerze? Jeden ch.....wali jedno, inny chwali drugie

Różnica jest tylko w widoczności zmiennej, szkoda sobie czasem zaśmiecać kod zmiennymi globalnymi

Tja, pomoże Ale wystarczyłby static

Ustaw duże tablice jako static lub zmienne globalne, wtedy nie będą trzymane na stosie.

10*100/20= 1000/20 = 500

Przelicz jeszcze raz.

Uprawnienia w AMXX
AMX Mod X, jako modyfikacja mająca ułatwić Administratorom pracę na serwerze, posiada system uprawnień.
Użytkownikom nadawane są pewne uprawnienia, które zezwalają na wykonywanie określonych operacji.
Do dyspozycji mamy 1024 uprawnienia dla każdego z graczy, a każde z nich to jeden bit, czyli 0 lub 1.
Uprawnienia podzielone są na 32 zestawy po 32 bity. Każdy taki bit nazywany jest zwyczajowo flagą.
 
Każdy z 32 zestawów uprawnień jest liczbą całkowitą typu U2 i przyjmuje wartości od -2³¹ = -2147483648 do 2³¹ - 1 = 2147483647.

Przeliczanie liczby dziesiętnej na U2
Liczbę dziesiętną D (na co dzień korzystamy z dziesiętnego systemu liczbowego) przeliczamy na U2 B,
gdzie B_n oznacza n-tą cyfrę od prawej (licząc od zera) trzydziestodwucyfrowej liczby binarnej B, np. dla:

B = 01000000000100000000010000000001

indeksy dla każdej z 32 cyfer to:

 

 

indeksy od 0 (po prawej) do 31 (po lewej); 1 ∈ { B₀ ; B₁₀ ; B₂₀ ; B₃₀ }

 

następująco:

• Jeśli D jest ujemne:
  • B₃₁ (pierwsza cyfra B od lewej) przyjmuje wartość 1.
  • D przyjmuje wartość o jeden mniejszą od swojej przeciwności (D = - D - 1).
• Jeśli D jest nieujemne:
  • B₃₁ (pierwsza cyfra B od lewej) przyjmuje wartość 0.
• Dla każdej kolejnej (od lewej) cyfry B_n:
  • _​jeśli aktualne D ≥ 2ⁿ:
    • przypisujemy wartość 1.
    • zmniejszamy D o 2ⁿ.
  • _​jeśli aktualne D < 2ⁿ:
    • przypisujemy wartość 0.

Przykład dla liczby D=13:

• B₃₁ = 0 (D=13 jest nieujemna)
• B₃₀ = 0 (D=13 < 2ⁿ⁼³⁰=1073741824)
• B₂₉ = 0 (D=13 < 2ⁿ⁼²⁹=536870912)

…

• B₄ = 0 (D=13 < 2ⁿ⁼⁴=16)
• B₃ = 1 (D=13 ≥ 2ⁿ⁼³=8)
  • D=D-2ⁿ=13-2³=13-8=5
• B₂ = 1 (D=5 ≥ 2ⁿ⁼²=4)
  • D=D-2ⁿ=5-2²=5-4=1​
• B₁ = 0 (D=1 < 2ⁿ⁼¹=2)
• B₀ = 1 (D=1 ≥ 2ⁿ⁼¹=1)
  • D=D-2ⁿ=1-2⁰=1-1=0

13 = 00000000000000000000000000001101

Przeliczanie liczby U2 na dziesiętną

 
Prostsza forma zapisu wzoru:


Dłuższa forma zapisu wzoru:

 
Liczbę U2 uzyskuje się poprzez zsumowanie iloczynów wartości każdego z 32 bitów i kolejnych, od prawej strony, potęg liczby 2, począwszy od potęgi zerowej.
Wyjątkiem jest tutaj iloczyn liczby pierwszej od lewej (o najwyższej potędze mnożnika dwójki, tj. 31), którego to odejmujemy od sumy, zamiast go do niej dodać.
 
Przykładowo, liczba 13 zapisywana jest binarnie w postaci:

00000000000000000000000000001101

Jedynki stoją na pozycjach: 0, 2 i 3 od prawej strony (licząc od zera), co daje nam wartość 2⁰+2²+2³ = 1+4+8 = 13.
Liczba 13 daje zatem nam 3 uprawnienia, mianowicie i roboczo "uprawnienie 0", "uprawnienie 2" i 'uprawnienie 3".
Każde uprawnienie oznacza jedynkę w kodzie binarnym naszej liczby, a zero oznacza brak tego uprawnienia.
 

Sprawdzanie uprawnień
Niech "uprawnienie N" będzie N-tym od prawej strony bitem zapisu zestawu uprawnień gracza w postaci U2.
Wiedząc, że przyjmuje ono wartość N-tej potęgi liczby 2 (bądź przeciwność tej potęgi w przypadku "uprawnienia 31"),
w łatwy sposób możemy sprawdzić, czy gracz posiada daną flagę, czy też nie. W tym celu najpierw pobierzemy flagi
uprawnień gracza, korzystając z funkcji get_user_flags, która zwróci nam liczbę całkowitą jako uprawnienia gracza.

new flags=get_user_flags(id);

Za pomocą iloczynu binarnego, w łatwy sposób sprawdzimy, czy gracz posiada daną flagę.

Iiloczyn binarny
Iloczyn binarny przyjmuje wartość 1, jeśli każda z mnożonych liczb wynosi 1, w przeciwnym przypadku przyjmuje wartość 0.
Dla każdej pary bitów o tym samym indeksie, liczymy ich iloczyn binarny i wynik zapisujemy jako bit o tymże właśnie indeksie.

Przykład:

13 = 00000000000000000000000000001101
 4 = 00000000000000000000000000000100
   & 00000000000000000000000000000100

Iloczyn binarny liczb 13 i 4 wyniesie 4, co oznacza, że posiadając uprawnienia równe 13, posiada się "uprawnienie 2" równe 2² = 4.
W pawnie, iloczyn binarny otrzymamy, używając znaku etki: &. Przyda nam się także przesunięcie bitowe, które przesuwa wszystkie bity.
Mamy do dyspozycji przesunięcie bitowe w lewo, w prawo arytmetyczie oraz prawo logicznie, nas będzie interesować przesunięcie bitowe w lewo.

Przesunięcie bitowe
Przesuwamy bity w lewo za pomocą operatora a << b podwajając wartość liczby a dokładnie b-krotnie. Przykład dla 13 << 3:

13      = 00000000000000000000000000001101
13 << 1 = 00000000000000000000000000011010
13 << 2 = 00000000000000000000000000110100
13 << 3 = 00000000000000000000000001101000

W ten sam sposób możemy uzyskać wartość flagi "uprawnienia N", przesuwając liczbę 1 N razy w lewo, co jest równe dokładnie 2^N. przykładowo "uprawnienie 3":

1 << 3 = 00000000000000000000000000001000

Chcąc się dowiedzieć, czy użytkownik posiada "uprawnienie N", wystarczy zsumować binarnie uprawnienia gracza z N-tą potęgą liczby 2:

get_user_flags(id) & (1 << N)

Przykład:

if(get_user_flags(id) & (1 << 3)){
	client_print(id, print_chat, "Posiadasz ^"uprawnienie 3^".");
}

Suma binarna
Suma binarna przyjmuje wartość 1, jeśli przynajmniej jedna z mnożonych liczb wynosi 1, w przeciwnym przypadku przyjmuje wartość 0.
Dla każdej pary bitów o tym samym indeksie, liczymy ich sumę binarną i wynik zapisujemy jako bit o tymże właśnie indeksie. Przykład:

12 = 00000000000000000000000000001100
 5 = 00000000000000000000000000000101
   | 00000000000000000000000000001101

Suma binarna liczb 12 i 5 wyniesie 13. W pawnie, sumę binarny otrzymamy, używając znaku barierki (tzw. pałki): |.
Za pomocą sumy binarnej, możemy sprawdzić, czy gracz posiada którąkolwiek z wielu flag, poprzez ich zsumowanie.

Przykład:

if(get_user_flags(id) & ((1 << 2) | (1 << 3) | (1 << 4))){
	client_print(id, print_chat, "Posiadasz ^"uprawnienie 2, 3 lub 4^".");
}

Chcąc  sprawdzić, czy użytkownik posiada wszystkie z wymaganych flag uprawnień, wykonujemy identyczne działanie,
porównując uzyskany wynik z sumą binarną flag, które poddaliśmy sprawdzeniu. Jeśli gracz nie będzie posiadał choć
jednej ze sprawdzanych flag, wynik iloczynu będzie mniejszy niż suma binarna sprawdzanych flag uprawnień.

Przykład:

if(
		get_user_flags(id)
	&	((1 << 2) | (1 << 3) | (1 << 4))
	== 	((1 << 2) | (1 << 3) | (1 << 4))
){
	client_print(id, print_chat, "Posiadasz wszystkie ^"uprawnienia 2, 3 oraz 4^".");
} 

Definicje preprocesora
Używanie postaci liczb jest jednak niepraktyczne i trudno jest spamiętać, za co dane uprawnienie odpowiada.
W tym celu, niektóre z flag uprawnień zostały zdefiniowane za pomocą komendy preprocesora: #define.

#define ADMIN_ALL		0	/* everyone */
#define ADMIN_IMMUNITY		(1<<0)	/* flag "a" */
#define ADMIN_RESERVATION	(1<<1)	/* flag "b" */
#define ADMIN_KICK		(1<<2)	/* flag "c" */
#define ADMIN_BAN		(1<<3)	/* flag "d" */
#define ADMIN_SLAY		(1<<4)	/* flag "e" */
#define ADMIN_MAP		(1<<5)	/* flag "f" */
#define ADMIN_CVAR		(1<<6)	/* flag "g" */
#define ADMIN_CFG		(1<<7)	/* flag "h" */
#define ADMIN_CHAT		(1<<8)	/* flag "i" */
#define ADMIN_VOTE		(1<<9)	/* flag "j" */
#define ADMIN_PASSWORD		(1<<10)	/* flag "k" */
#define ADMIN_RCON		(1<<11)	/* flag "l" */
#define ADMIN_LEVEL_A		(1<<12)	/* flag "m" */
#define ADMIN_LEVEL_B		(1<<13)	/* flag "n" */
#define ADMIN_LEVEL_C		(1<<14)	/* flag "o" */
#define ADMIN_LEVEL_D		(1<<15)	/* flag "p" */
#define ADMIN_LEVEL_E		(1<<16)	/* flag "q" */
#define ADMIN_LEVEL_F		(1<<17)	/* flag "r" */
#define ADMIN_LEVEL_G		(1<<18)	/* flag "s" */
#define ADMIN_LEVEL_H		(1<<19)	/* flag "t" */
#define ADMIN_MENU		(1<<20)	/* flag "u" */
#define ADMIN_ADMIN		(1<<24)	/* flag "y" */
#define ADMIN_USER		(1<<25)	/* flag "z" */

amxconst.inc

Dzięki tym definicjom, zamiast potęg dwójki, możemy, używać zdefiniowanej nazwy.
W przykładzie użyjemy naszego "uprawnienia 3", zapisanego jako ADMIN_BAN:

if(get_user_flags(id) & ADMIN_BAN){
	client_print(id, print_chat, "Posiadasz ^"uprawnienie 3^".");
}

Pomimo pokaźnych i użytecznych definicji, 9 flag uprawnień wciąż nie zostało zdefiniowanych.
Możemy to zrobić sami, np. poprzez zdefiniowanie następujących definicji (nazwy mogą być inne):

#define ADMIN_FLAG_V		(1<<21)	/* flag "v" */
#define ADMIN_FLAG_W		(1<<22)	/* flag "w" */
#define ADMIN_FLAG_X		(1<<23)	/* flag "x" */
#define ADMIN_FLAG_COMMA	(1<<26)	/* flag ";" */
#define ADMIN_FLAG_BAR		(1<<27)	/* flag "|" */
#define ADMIN_FLAG_EQUAL	(1<<28)	/* flag "=" */
#define ADMIN_FLAG_TILDE	(1<<29)	/* flag "~" */
#define ADMIN_FLAG_QUESTION	(1<<30)	/* flag "?" */
#define ADMIN_FLAG_SPACE	(1<<31)	/* flag " " */

Flagi jako znaki ASCII
Alternatywną metodą zapisu flag uprawnień do potęg liczby 2, są znaki ASCII.
Aby określić wartość liczbową, jakiej odpowiada dany znak, najpierw musimy
pobrać jego identyfikator z listy ASCII: Lista 128 znaków ASCII na wiki.
Po poznaniu identyfikatora, możemy określić jego wartość, która
wynosi 2 do potęgi reszty z dzielenia identyfikatora przez 32.
 
Innymi słowy, wartość liczbowa D dowolnego znaku ASCII o identyfikatorze C wynosi:

 
Przykład dla pawna:

// returns flag value by given ASCII code
stock ASCII2DEC(ASCII_ID){
	ASCII_ID = ASCII_ID % 32;	// identyfikator dzielimy modulo 32, bo mamy 32 flagi uprawnień
	return power(2, ASCII_ID);	// podnosimy 2 do potęgi tego identyfiaktora, uzyskując wartośc flagi
}

W pawnie mamy też funkcję, która zwraca wartość flagi na podstawie samego znaku, nie jego wartości, co jest
jeszcze bardziej przydatne. Funkcją tą jest read_flags, która potrafi także zwrócić sumę binarną wielu flag naraz.
 
Przykład:

log_amx("%d", read_flags(""));		// zwróci 0
log_amx("%d", read_flags("a"));         // zwróci 1             // =  2!0
log_amx("%d", read_flags("b"));		// zwróci 2		// =  2!1
log_amx("%d", read_flags("ab"));	// zwróci 3		// =  2!0+2!1
log_amx("%d", read_flags("acd"));	// zwróci 13		// =  2!0+2!2+2!3
log_amx("%d", read_flags("z"));		// zwróci 33554432	// =  2!25
log_amx("%d", read_flags(";"));		// zwróci 67108864	// =  2!26
log_amx("%d", read_flags(" "));		// zwróci -2147483648	// = -2!31

Skoro wartość znaku ASCII jest dzielona modulo przez 32, to wszelkie znaki o indeksach różnicy wielokrotności 32 oznaczają tę samą wartość.
W szczególności, nie ma znaczenia wielkość liter, gdyż oddalone są one od siebie o 32 znaki ASCII. Pomimo obsługiwania wszystkich 32 znaków
ASCII z pliku users.ini oraz odpowiedniego konwertowania w funkcji read_flags, komenda amx_who jest w stanie odczytać jedynie
wartości liczb do 26. potęgi dwójki włącznie, przez co nie można tą komendą zobaczyć posiadanych flag o wyższych wartościach, tj.
flag "średnik", "pałka", "znak równości", "tylda", "znak zapytania" oraz "spacja" pomimo, że są one nadane i możliwe do odczytania.

Flagi w pluginach standardowych AMXX
Aby używać systemu flag, muszą one zostać nadane użytkownikowi, a następnie w jakiś sposób wykorzystane.
Standardowe pluginy AMXX odczytują uprawnienia określonych graczy z pliku amxmodx/configs/users.ini.
To, w jaki sposób należy przyznawać tam uprawnienia, jest kwestią dla end userów i wyjaśnioną w tym pliku.
Jeśli użytkownik nie otrzyma żadnych uprawnień z pliku users.ini, zostaną mu przypisane flagi z cvaru amx_default_access.
Domyślnie, jest to flaga "z". Flagi, same w sobie nie oznaczają i nie robią absolutnie nic, dopiero pluginy mogą te flagi wykorzystać.
 
Standardowe pluginy AMXX, flagę "a" uznają jako immunitet i nie pozwalają na wykonanie niektórych akcji na użytkownikach z tą flagą.
Flaga "b" zapewnia tzw. slot, "c" pozwala na wyrzucanie graczy z serwera, "d" na ich banowanie, itd. przy czym flaga "z" przypisana jakiemukolwiek
użytkownikowi, pomimo posiadania innej, wymaganej flagi, np. nie pozwala na wykonanie danej operacji, Jest to takie profilaktyczne zabezpieczenie.
Przykładowo, Administrator, posiadający flagi "cz", nie może wyrzucać graczy z serwera pomimo posiadania flagi "c".
Spełnia on wymów konieczny, tzn. posiada flagę "c", ale nie spełnia wymogu wystarczającego, tzn. ma też flagę "z".
 
Wchodząc na serwer z plikiem users.ini, którego zawartość wynosi:

"STEAM_0:1:57046937" "" "abcdefghijklmnopqrstuvwxy;|=~? " "ce"

zostaną mi przypisane wszystkie flagi uprawnień i uprzedzając pytania: jest to ustawienie dające najwięcej flag, nie zabierając możliwości
korzystania z pozostałych (czyt. brak flagi "z"). Uprawnienie to w postaci liczby dziesiętnej wynosi dokładnie -33554433. W postaci U2:

11111111111111111111111110111111

Ten sam efekt osiągniemy za pomocą wywołania funkcji:

set_user_flags(id, -1);
remove_user_flags(id, ADMIN_USER);

Jak sprawdzić, czy dany gracz posiada flagę, której nie wyświetla nawet komenda amx_who?
Tak samo, jak robimy to dla każdej innej flag. Poniżej 5 najczęściej stosowanych metod:
 
Przykład dla flagi "?" w postaci liczby wprost:

if(get_user_flags(id) & 1073741824){
	client_print(id, print_chat, "Posiadasz flagę ^"znak zapytania^".");
}

Przykład dla flagi "?" w postaci liczby jako potęgi dwójki:

if(get_user_flags(id) & (1 << 30)){
	client_print(id, print_chat, "Posiadasz flagę ^"znak zapytania^".");
}

Przykład dla własnej definicji preprocesora:

#define ADMIN_FLAG_QUESTION	(1<<30)	/* flag "?" */

if(get_user_flags(id) & ADMIN_FLAG_QUESTION){
    client_print(id, print_chat, "Posiadasz flagę ^"znak zapytania^".");
}

Przykład z funkcją read_flags:

if(get_user_flags(id) & read_flags("?")){
    client_print(id, print_chat, "Posiadasz flagę ^"znak zapytania^".");
}

Przykład z funkcją biblioteki amxmisc: has_flag:

if(has_flags("?")){
    client_print(id, print_chat, "Posiadasz flagę ^"znak zapytania^".");
}

Flagi w pluginach autorskich AMXX
Role flag ze standardowych pluginów AMXX stały się na tyle popularne, że niektórzy Administratorzy utożsamiają flagi z uprawnieniami.
Wiele autorskich pluginów także korzysta z domyślnych ról standardowych pluginów AMXX, szczególnie ustalając immunitet na flagę "a".
Niewielu administratorów korzysta z jakiejkolwiek z 9 flag, których nazwa nie została zdefiniowana w preprocesorze komendą #define ,
Niemal żaden z pluginów nie korzysta natomiast z żadnego z pozostałych 31 zestawów uprawnień o identyfikatorach od 1 do 31.
 
Przykład praktyczny wykorzystania niedomyślnego zestawu uprawnień: ustawienia blokowania chatu innym graczom:
 
Wykorzystamy w przykładzie zestaw uprawnień nr 1.
Po dołączeniu nowego gracza do gry, wyzerowane zostaną jego uprawnienia, co nam odpowiada.
Niechaj każda flaga w zestawie uprawnień 1 oznacza, czy gracz o identyfikatorze równym tej fladze został zablokowany przez właściciela tych flag.
Sama flaga równa identyfikatorowi gracza niech oznacza zaś, czy sam gracz został uciszony globalnie przez Administrację, czy też nie.
 
Pozwólmy graczom na indywidualne blokowanie chatu innych graczy komendą /block name, gdzie name to nick gracza uciszanego.
Odblokować gracza komendą /unblock name, a będąc Administratorem, zablokować całkowicie chat gracza, którego właśnie
obserwujemy, komendą /ucisz i odblokować jego czat komendą /ub. Przykładowy kod, który działa na zestawie uprawnień nr 1:

#include <amxmodx>
#include <ColorChat>
#include <fakemeta>

new maxPlayers;

public plugin_init(){
	register_plugin("system uciszania", "1.0", "Benio");
	register_clcmd("say", "say");
}

public plugin_cfg(){
	maxPlayers=get_maxplayers(); // pobieramy maksymalną liczbę graczy na serwerze
}

public say(id){
	if(id>0 && id<=maxPlayers){ // sprawdzamy tylko, jeśli piszący na czacie jest graczem
		new txt[192];
		read_args(txt,192); // czyta tekst
		remove_quotes(txt); // usuwa cudzysłowia
		
		if(equal(txt, "/block ", 7)){ // filtrujemy komendę jedynie do blokującej
			copy(txt, 185, txt[7]);
			
			new player2block = find_player("b", txt); // szukamy gracza do zablokowania
			if(player2block){ // jeśli znaleźliśmy gracza do zablokowania,
				set_user_flags(id, 1<<(player2block%32), 1); // to blokujemy, ustawiając flagę jego identyfikatora na 1
			}
		}
		
		if(equal(txt, "/unblock ", 9)){ // filtrujemy komendę jedynie do odblokującej
			copy(txt, 185, txt[9]);
			
			new player2unblock = find_player("b", txt); // szukamy gracza do zablokowania
			if(player2unblock){ // jeśli znaleźliśmy gracza do odblokowania,
				remove_user_flags(id, 1<<(player2unblock%32), 1); // to odblokowania, ustawiając flagę jego identyfikatora na 0
			}
		}
		
		if(equal(txt, "/ucisz ", 7)){ // filtrujemy komendę jedynie do uciszającej
			new player2shutup = pev(id, pev_iuser2); // pobieramy gracza do uciszenia na czacie
			if(player2shutup){ // jeśli znaleźliśmy gracza do uciszenia,
				set_user_flags(id, 1<<(player2shutup%32), 1); // to uciszamy, ustawiając flagę wlasnego jego identyfikatora na 1
			}
		}
		
		if(equal(txt, "/ub ", 4)){ // filtrujemy komendę jedynie do odbanowującej
			new player2ub = pev(id, pev_iuser2); // pobieramy gracza do odbanowania na czacie
			if(player2ub){ // jeśli znaleźliśmy gracza do odbanowania,
				remove_user_flags(id, 1<<(player2ub%32), 1); // to odbanowujemy, ustawiając flagę wlasnego jego identyfikatora na 0
			}
		}
		
		if(get_user_flags(id, 1) & (1<<(id%32))){ // sprawdzamy, czy gracz nie został uciszony przez Administrację
			client_print(id, print_chat, "Zostałeś uciszony. Nie możesz używać chatu");
			
			return PLUGIN_HANDLED_MAIN;
		}
		
		new name[32];
		get_user_name(id, name, 31); // pobranie nicku gracza
		
		for(new i=1; i<=32; ++i){ // wysyłamy wiadomośc do wszystkich graczy, którzy nie zablokowali gracza piszącego na czacie
			if(is_user_connected(i) && !(get_user_flags(i, 1) & (1<<(id%32)))){
				ColorChat(i, TEAM_COLOR, "%s^x01 :  %s", name, txt);
			}
		}
		
		return PLUGIN_HANDLED_MAIN; // blokujemy domyślne wywołanie saya przez silnik gry (już obsłużyliśmy saya)
	}

	return PLUGIN_CONTINUE;
}

 
Dodatkowe zestawy uprawnień można także wykorzystać jako oznaczenie posiadanych / użytych przedmiotów dodatkowych.
Flagi uprawnień są na tyle korzystne, że bez problemu można odczytywać i modyfikować ich ustawienia z dowolnego pluginu, bez konieczności
korzystania z natywów, forwardów, ustawiania cvarów serwera, wywoływania komendy u klienta, czy wywoływania funkcji publicznych innego pluginu.
 
Dodawanie i zabieranie flag uprawnień
Do dodania graczowi flag uprawnień służy funkcja set_user_flags, która wbrew pozorom dodaje flagi, a nie ustala.
Użycie domyślnej wartości -1 w drugim parametrze funkcji set_user_flags da graczowi wszystkie możliwe flagi uprawnień (łącznie z "z").
Funkcja ustala graczowi uprawnienia, będące sumą binarną jego obecnie posiadanych uprawnień i dodawanych przez drugi argument funkcji.
 
Przykład:

set_user_flags(id, ADMIN_BAN); // dodaje graczowi flagę ADMIN_BAN = 1<<3, czyli "uprawnienie 3"
set_user_flags(id, read_flags("d")); // dodaje graczowi tę samą flagę, której wartość zwraca funkcja read_flags.

 
Do odebrania graczowi flag uprawnień służy funkcja remove_user_flags.
Użycie domyślnej wartości -1 w drugim parametrze funkcji remove_user_flags odbierze graczowi wszystkie możliwe flagi uprawnień (łącznie z "z").
Funkcja ustala graczowi uprawnienia, będące iloczynem binarnym jego obecnie posiadanych uprawnień i negacji bitów dodawanych przez drugi argument funkcji.

Przykład:

remove_user_flags(id, ADMIN_BAN); // odbiera graczowi flagę ADMIN_BAN = 1<<3, czyli "uprawnienie 3"
remove_user_flags(id, read_flags("d")); // odbiera graczowi tę samą flagę, której wartość zwraca funkcja read_flags.

amxmisc
Funkcje z biblioteki amxmisc z reguły są niepotrzebne i mogą być łatwo zastąpione, aczkolwiek jest to alternatywna metoda do odczytywania uprawnień:
 
Funkcja has_flag pozwala na sprawdzenie, czy gracz posiada którąkolwiek z podanych flag w postaci znaków ASCII.
Funkcja has_all_flags pozwala na sprawdzenie, czy gracz posiada wszystkie z podanych flag w postaci znaków ASCII.
Funkcja access pozwala na sprawdzenie, czy gracz posiada podaną flagę podaną w postaci liczby dziesiętnej.
Funkcja cmd_access pozwala na sprawdzenie wewnątrz komendy, czy gracz posiada flagę podaną w postaci liczby dziesiętnej przy rejestrowaniu tej komendy.

A gdzie równouprawnienia ja się pytam? Dyskryminacja mężczyzn? Żądam równouprawnień! Pozdro. dla chłopaków

 

Gdy kobiety nie mają większych praw niż mężczyźni, pojawia się banda dzikich feministek bez sensownych argumentów.

Cod stary podwójny exp za fraga

Do public Death() dodajesz

if(klasa_gracza[attacker] == XX) // Zamiast XX dajesz swoją klasę
nowe_doswiadczenie *= 2;

Tutorial dla początkujących
Informacje wstępne
Scripting AMXX


[kotwica='cel']Cel[/kotwica]
Nauka tworzenia pluginów AMXX

Wymagania

• Znajomość obsługi AMXX
• Umiejętność programowania
• Podstawowa znajomość Pawna
• Racjonalne tworzenie algorytmów
• Umiejętność korzystania z manuala
• Edytor Pawna wraz z kompilatorem AMXX

[kotwica='wstep']Wstęp[/kotwica]
Na samym początku zadajmy sobie pytanie: czym są pluginy AMXX i jak działają.

Pluginy AMXX to algorytmy modyfikacji rozgrywki na serwerach HLDS, pisane w języku Pawn,
zrozumiałym dla ludzi i zapisywane pod postacią plików SMA, które w wyniku kompilacji przybierają
postać kodu niezrozumiałego dla człowieka, ale zrozumiałego dla AMXX, zapisywane pod postacią
plików AMXX, które komunikują się z serwerem HLDS poprzez Metamoda:P, zmieniając rozgrywkę.

[kotwica='istota']Istota[/kotwica]
Tym samym, plugin komunikuje się z Metamodem:P, a Metamod:P z silnikiem gry (serwerem HLDS).
Musimy pamiętać, że każda wymiana informacji pomiędzy serwerem a silnikiem gry, zużywa liczne
zasoby sprzętowe i należy zadawać możliwie jak najmniej zapytań do silnika gry poprzez Metamoda:P.

[kotwica='plugins_ini']Plugins.ini[/kotwica]
Plik plugins.ini zawiera listę pluginów, które zostaną załadowane do AMXX i będą wykonywać swoje
algorytmy, komunikując się z serwerem HLDS poprzez MetaModa:P, modyfikując przebieg gry.

Jednak kolejność pluginów wpisanych w pliku plugins.ini nie jest bez znaczenia.
Zwróćmy teraz uwagę na sposób działania AMXX, czyli interakcję z serwerem gry.
AMXX pozwala nam, poprzez MetaModa:P, na następujące operacje:

• Zarejestrowanie danego zdarzenia czy wartości (np. odczytanie liczby pieniędzy danego gracza, czy zaobserwowanie wybuchu bomby)
• Modyfikowanie danego zdarzenia czy wartości (np. zmiana punktów życia danego gracza, czy przedłużenia czasu trwania oślepienia)
• Zablokowanie danego zdarzenia czy usunięcie wartości (np. brak obrażeń od granatów, czy usunięcie limitu posiadanych dolarów)
• Wywołanie danego zdarzenia (np. zabicie gracz, teleportacja gracza na respawn wrogów, czy pozbawienie gracza jego broni)
• Tworzenie danego zdarzenia czy wartości (np. zabicie vipa lub ucieczka terrorystów, czy stworzenie nowych cvarów)

Tym samym, poszczególne pluginy mogą być od siebie zależne, a ich kolejność ma znaczenie.
Należy zatem zwracać uwagę na kolejność pluginów w pliku plugins.ini, przy czym algorytmy
kolejnych pluginów, od góry pliku plugins.ini, wykonywane są proporcjonalnie sekwencyjnie.

Przykładowo, jeśli w pluginie pierwszym od góry pliku plugins.ini, zablokujemy możliwość mówienia,
to w pluginie drugim od góry, nie zostanie zarejestrowane powiedzenie na sayu określonej wartości.
W odwrotnej kolejności tych pluginów w pliku plugins.ini zaś, będzie to z kolei możliwe do wykonania.

[kotwica='AMXMODX']AMXMODX[/kotwica]
Pierwszą, podstawową biblioteką, jaką będziemy musieli załączyć do naszego pluginu, jest AMXMODX.
W tym celu, dodajemy na samej górze naszego kodu SMA następującą linijkę kodu

#include <amxmodx>

AMXX posiada parę publicznych, predefiniowanych funkcji, a oto one:

[kotwica='plugin_natives']plugin_natives[/kotwica]
Ta funkcja wywoływana jest jako pierwsza, tuż po załadowaniu pluginu do pamięci AMXX.
W niej należy zainicjować wszelkie natywy do współpracy z innymi pluginami, czyli sprawić,
by możliwa była kompleksowa komunikacja pomiędzy funkcjami poszczególnych pluginów.

Jak już pisałem, funkcje ładowane są kolejno, od góry pliku plugins.ini, tak więc kolejność jest istotna.

[kotwica='plugin_precache']plugin_precache[/kotwica]
Ta funkcja wywoływana jest po załadowaniu wszytkich pluinów z natywami, lecz jeszcze przed pełnym zainicjowaniem
serwera HLDS i to w niej należy zarejestrować wszelkie wymagane do pobrania przez Użytkowników pliki niestandardowe,
z których będzie korzystał plugin, by powiadomić klienta gry o konieczności pobrania tych plików przed ustaleniem połączenia.

W tej właśnie funkcji należy zarejestrować wszelkie modyfikatory skryptów startowych serwera HLDS, by móc
w nie ingerować, zanim zostaną załadowane i wykonane skrypty startowe, uniemożliwiając ich identyfikację.

[kotwica='plugin_init']plugin_init[/kotwica]
Ta funkcja wywoływana jest podczas inicjalizacji pluginu, po pełnym załadowaniu funkcji startowych serwera.
W tej funkcji należy zarejestrować nasz plugin przy użyciu funkcji register_plugin o następujących parametrach

register_plugin(const plugin_name[], const version[], const author[])

Warto zidentyfikować plugin w celu późniejszego testowania stanu pluginu i odnalezienia go na liście pluginów.
Składnia argumentów funkcji nie wymaga chyba większego komentarza, w przypadku wątpliwości zapraszam do manuala.

[kotwica='przyklad']Przykład[/kotwica]
Na tym etapie, potrafimy już stworzyć i zarejestrować pierwszy plugin, nie robiący praktycznie nic.

#include <amxmodx>

public plugin_init(){
	register_plugin("Nauka AMXX", "0.1", "benio101");
}

Przypomnijmy, w pierwszej linijce zaimportowaliśmy wymaganą zawsze dla AMXX, bibliotekę amxmodx.
W trzeciej linijce zainicjowaliśmy publiczną funkcję plugin_init, wykonywaną po pełnym załadowaniu skryptów startowych HLDS.
Przypominam, że funkcja plugin_init winna być funkcją publiczną, inaczej może nie zostać ona wykonana w oczekiwanym momencie.
W czwartej linijce, rejestruję plugin i na tym kończy się działanie naszego testowego pluginu, który praktycznie nie zmienia rozgrywki.

W funkcji plugin_init należy także zarejestrować wszelkie nasłuchiwacze zdarzeń, jak śmierć gracza, czy nowa runda.

[kotwica='plugin_cfg']plugin_cfg[/kotwica]
Ta funkcja wywoływana jest tuż po plugin_init i służy konfiguracji pluginu, m.in. pobraniu zmiennych globalnych z silnika gry,
ustanowieniu połączenia z bazą danych, czy pobrania innych, istotnych danych do współpracy pluginu z zasobami zewnętrznymi.

[kotwica='register_event']register_event[/kotwica]
Pierwsza z funkcji, którą poznamy, pozwala na przechwycenie wybranych zdarzeń, które dokonywane są na serwerze.
Tutaj odwołuję do niezwykle istotnej strony, na której wypisane są zdarzenia silnika HLDS wraz z argumentami:

Half-Life 1 Game Events

Teraz spróbujemy przechwycić funkcję śmierci, w tym celu musimy zarejestrować w funkcji plugin_init nasłuchiwacz tego zdarzenia

register_event("DeathMsg", "DeathMsg", "a");

Pierwszy parametr, zgodnie z dokumentacją, oznacza nazwę zdarzenia.
Drugi parametr oznacza funkcję publiczną, która będzie wywoływana w momencie wystąpienia tego zdarzenia. Trzeci parametr
wynosi "a", gdyż DeathMsg jest eventem globalnym. Tym samym utworzymy sobie funkcję publiczną DeathMsg i damy zabójcy 200$.

[kotwica='read_data']read_data[/kotwica]
Jak możemy wyczytać z powyższego linku, DeathMsg posiada cztery argumenty. Nam wystarczy pierwszy argument, czyli id zabójcy.

public DeathMsg(){
	new killer=read_data(1);
}

Funkcja DeathMsg wywoływana jest w momencie wystąpienia zdarzenia śmierci.
Za pomocą funkcji read_data możemy odczytać dany parametr funkcji, ponieważ pierwszy argument
to numer identyfikacyjny zabójcy, ten właśnie numer pobierzemy i zapiszemy do nowo utworzonej zmiennej killer.
Teraz będziemy chcieli nagrodzić zabójcę, przekazując mu dodatkowe 200 dolarów za zabójstwo.
W tym celu, skorzystamy z funkcji z biblioteki cstrike, cs_set_user_money.

[kotwica='import_biblioteki']Import biblioteki[/kotwica]
Aby móc skorzystać z tej funkcji, musimy najpierw zaimportować kolejną bibliotekę,
w tym celu dodajemy do naszego kodu następującą linijkę (najlepiej pod bilioteką amxmodx)

#include <cstrike>

Przypomnijmy, jak powinien wyglądać nasz obecny, pełny kod:

#include <amxmodx>
#include <cstrike>

public plugin_init(){
	register_plugin("Nauka AMXX", "0.1", "benio101");

	register_event("DeathMsg", "DeathMsg", "a");
}

public DeathMsg(){
	new killer=read_data(1);
}

[kotwica='sprawdzenie_obecnosci_gracza']Sprawdzenie obecności gracza[/kotwica]
Teraz dochodzimy do niezwykle istotnej rzeczy, którą musisz zapamiętać raz na zawsze!
Operując na jakimkolwiek graczu, upewnij się, że gracz może zostać danej operacji poddany.
W przykładzie, chcemy dodać pieniądze graczowi, jednak zanim to zrobimy, musimy się upewnić,
czy gracz jest jeszcze na naszym serwerze. Zawsze mógł rzucić granat, wyjść z serwera, a opiero po chwili
nastąpi zdarzenie śmierci. Co się stanie przy próbie dodania pieniędzy graczowi, którego nie ma na serwerze?
Na pewno jest to niepotrzebne zapytanie do silnika gry, dużo większe zużycie zasobów sprzętowych, a także stale
powiększające się logi błędów. Na dłuższą metę, takie właśnie błędy skutkują dużymi lagami bądź crashami serwera.

Tym samym, użyjemy funkcji is_user_connected, w celu sprawdzenia, czy gracz jest jeszcze na serwerze.
Pamiętajmy, że aktualnie killer reprezentuje numer identyfikacyjny zabójcy, jednak w różnych funkcjach, możemy różnie
identyfikować poszczególne byty czy zdarzenia. Przy okazji, każdy byt na mapie ma swój własny, unikalny numer identyfikacyjny,
jednakże numerem identyfikacyjnym gracza jest numer z zakresu od 1 do maksymalnej liczby graczy włącznie. Tym samym, numer
bytu, będący większy lub równy 1 i nie większy, niż maksymalna liczba graczy na serwerze, oznacza na pewno gracza. (niekoniecznie online!)

public DeathMsg(){
	new killer=read_data(1);
	if(is_user_connected(killer)){
		// Dodawanie pieniedzy
	}
}

Teraz skorzystamy z natywów biblioteki cstrike i dodamy zabójcy 200 dolarów.

cs_set_user_money(killer, cs_get_user_money(killer) + 200);

Jak można zauważyć, nie mamy wprost funkcji dodającej pieniądze. W związku z tym,
musimy jako drugi parametr funkcji cs_set_user_money podać sumę 200
i obecnej liczby dolarów gracza, pobieranej przy użyciu funkcji cs_get_user_money

[kotwica='zwracana_wartosc']Zwracana wartość[/kotwica]
W nowo utworzonej funkcji DeathMsg, zwrócimy na końcu odpowiednią wartość.
Dostępne wartości do zwrócenia:

PLUGIN_CONTINUE
Domyślna wartość, przerywająca dalsze wywołanie funkcji, jednak przez każdy inny plugin, a także silnik gry,
zdarzenie zostanie wywołane. Po prostu nic niżej od tego polecenia nie zostanie wywołane w tej danej jednej funkcji.

PLUGIN_HANDLED_MAIN
Dalsze wywołanie funkcji nie będzie możliwe, podobnie, jak w przypadku PLUGIN_CONTINUE, dalej wszystkie
pluginy będą mogły odnotować tę funkcję, jednak event ten zostanie zablokowany dla silnika właściwego gry.

PLUGIN_HANDLED
Dalsze wywoływanie funkcji zostanie przerwane, a ani silnik gry nie odnotuje tego eventu, ani, w przeciwieństwie
do PLUGIN_HANDLED_MAIN, żaden z kolejnych pluginów, wypisanych poniżej od tego obecnego w plugins.ini.

Nam wystarczy PLUGIN_CONTINUE, bowiem nie chcemy blokować śmierci w silniku, ani pozbawiać informacji o śmierci
kolejnych pluginów. Na koniec zmienimy nazwę pluginu na odzwierciedlającą rzeczywiste zastosowanie pluginu. Gotowy kod:

#include <amxmodx>
#include <cstrike>

public plugin_init(){
	register_plugin("Dodatkowe 200 dolarow za zabojstwo", "0.1", "benio101");

	register_event("DeathMsg", "DeathMsg", "a");
}

public DeathMsg(){
	new killer=read_data(1);
	if(is_user_connected(killer)){
		cs_set_user_money(killer, cs_get_user_money(killer) + 200);
	}
	return PLUGIN_CONTINUE;
}

Tym samym, właśnie napisaliśmy swój pierwszy plugin, który daje dodatkowe 200 dolarów za zabójstwo.


Tutorial napisany, choć z drobnym opóźnieniem, z okazji Światowego Dnia Jakości.
Jeśli przypadnie on Wam do gustu, to mogę pokusić się w wolnym czasie o napisanie kolejnych
części, jako kontynuację, z rozwinięciem wątku i coraz bardziej zaawansowanymi przykładami Scriptingu.

Dodaj:

#include <engine>

To:

register_forward(FM_Touch, "fwd_touch")

zamień na:

register_touch("player", "*", "fwd_touch");

Zamień publica:

public fwd_touch(id, world)
{
    if(!is_user_alive(id) || klasa_gracza[id] != Wspinacz || !pev_valid(id))
        return FMRES_IGNORED
 
 
    new classname[STR_T]
    if(pev_valid(world))
    pev(world, pev_classname, classname, (STR_T))
    else
    return FMRES_IGNORED
 
    if(equal(classname, "worldspawn") || equal(classname, "func_wall") || equal(classname, "func_breakable"))
        pev(id, pev_origin, g_wallorigin[id])
 
    return FMRES_IGNORED
}

Nie testowałem, nie wiem czy zadziała, ale zawsze warto zobaczyć, bo może register_touch i register_forward działają inaczej.

 

@P.S Jak to mówią nie mam już pomysłów

 

Co do pierwszego chyba musisz znaleźć inny sposób, bo pev_valid działa na enty/byty, a u Ciebie prawdopodobnie dotykasz po prostu bryły, która nie jest entem.

Tutaj nie jestem pewien, takie przypuszczenia mappera, nie bawię się często z entami.

 

Drugie skoro jest index out of bounds to znaczy, że "item" przekracza rozmiar np. 123 lub -1 (chyba wychodzenie z menu daje taki efekt?)

 

Przed:

if(!is_user_connected(oddaj_id[item])) ////// ta linijka

Dodaj

if(item == MENU_EXIT || item < 0 || item > 119)

return PLUGIN_CONTINUE;

 

Coś mi też się wydaję, że o nie taki efekt Ci chodzi w tym menu, bo dziwnie to wygląda, ale Testing is the future

 

 

Poprawiłem przed chwilą, ale widzę po statystykach, że już działa.

public DeathMsg(id)

{

    new vid = read_data(2)

        

    reset_player(vid)

    msg_bartime(id, 0)

    static Float:minsize[3]

    pev(vid, pev_mins, minsize)

    if(minsize[2] == -18.0)

        g_wasducking[vid] = true

    else

        g_wasducking[vid] = false

    

    set_task(0.5, "task_check_dead_flag", vid)

}

na

public DeathMsg(id)

{

    new vid = read_data(2)

        

if(is_user_connected(vid))

    reset_player(vid)



    msg_bartime(id, 0)

    static Float:minsize[3]

    pev(vid, pev_mins, minsize)

    if(minsize[2] == -18.0)

        g_wasducking[vid] = true

    else

        g_wasducking[vid] = false

    

    set_task(0.5, "task_check_dead_flag", vid)

}

Historia banów (oryginalny motd)
Wersja poprawiona dziś (tj. 12.09.2012)
paczka zawiera Nowy Mod - MOTD