Miczu

Dynamiczny HUD
dHUD.inc
v.1.03

Temat w budowie, stworzenie dokumentacji potrwa pewnie dłużej niż pisanie kodu
Tymczasem angielski opis wszystkich funkcji można znaleźć w pliku .inc

Demonstracja

Eksperymentalna biblioteka do tworzenia różnych efektów na wiadomościach HUD. Jej głównym (lecz nie jedynym) zadaniem jest zautomatyzowanie ruchu i zmian koloru wyświetlanych komunikatów.



Plugin udostępnia szereg funkcji do pracy z efektami. Podstawowe operacje odbywają się na pojedynczych klatkach animacji, jak we flashu. Tak też wyświetlana jest wiadomość - klatka po klatce - zastąpienie napisu jego kopią w innym miejscu czy kolorze stworzy wrażenie ruchu i przekształceń kolorystycznych.

Download

• v1.03 (zalecane)
   dHUD-1.03.rar   5,94 KB  625 Ilość pobrań
  
• v1.02
   dHUD-1.02.rar   5,97 KB  216 Ilość pobrań
  
• v1.01
   dHUD.rar   5,78 KB  203 Ilość pobrań
  
  
• przykładowy kod
   dHUD_test.sma   2,31 KB  526 Ilość pobrań
    dHUD_test.amxx

Instalacja
Plik dHUD.sma należy skompilować i zainstalować na serwerze. Plugin korzystający z efektów skompiluje się wyłącznie lokalnie z dostępem do dHUD.inc.


Interfejs
Wszystkie udostępniane funkcje mają prefiks DHUD_*.

Pierwsze co trzeba zrobić to stworzyć 'obiekt' dhud. DHUD_create() zwraca uchwyt, którego używa się z pozostałymi funkcjami. Można utworzyć kopię istniejącego obiektu przez podanie jego uchwytu DHUD_create(dhud) [działa to podobnie jak konstruktor kopiujący w językach obiektowych].


Animację możemy zaprojektować manualnie przypisując właściwości każdej klatce z osobna (dHUD_test -> dhud) lub użyć filtrów (dHUD_test -> dhud3).

• klatka po klatce

Wystarczy kilka wywołań DHUD_setFrame, każde przypisze kolor i położenie napisu tworząc animację

DHUD_setFrame(dhud, frame, iColor[3], Float:x, Float:y, iLen = 1);

dhud - uchwyt
frame - numer klatki, zaczynają się od 0, w przypadku numeru większego niż liczba dostępnych akurat klatek animacja zostaje wypełniona pustymi klatkami aż do podanego rozmiaru
iColor[3] - kolor napisu
x, y, - położenie napisu
iLen - długość klatki; w miejsce dwóch identycznych klatek z iLen=1 można dać jedną z iLen=2

• filtry

Filtry służą do przetwarzania kilku klatek zgodnie z danym algorytmem.

DHUD_applyFilter(dhud, const szFilter[], startFrame, endFrame, Float:dx=D_LONG, Float:dy=D_ZERO, any:...)

dhud - uchwyt
szFilter[] - nazwa filtra, lista dostępnych jest drukowana po użyciu komendy "dhud info" przez admina z flagą od konfiguracji (H)
startFrame, endFrame - przedział klatek
dx, dy - przyrost wartości x i y, przydatne w funkcjach, funkcja realizująca filtr otrzymuje współrzędne x i y, z których może wyliczyć nowe położenie (przykład z sinusem w dHUD_test), każda ramka dostaje wartości x<poprzedniej ramki> + dx i y<poprzedniej ramki> + dy
any:.. dodatkowe parametry filtrów, opisane także w "dhud info"



Dwoma podstawowymi filtrami dHUD są SetPosition i SetColor. Dzięki nim, możemy ustawić kolor i położenie w wielu klatkach jednocześnie.

SetPosition ustawia podaną pozycję wszystkim klatkom z zakresu startFrame-endFrame
SetColor ustawia podany kolor wszystkim klatkom z zakresu startFrame-endFrame

Ten kod ustawi dhud długości 50 klatek w pozycji 0.5 0.5 w kolorze białym (255, 255, 255)

DHUD_setFrame(dhud, 50, {0,0,0}, 0.0, 0.0);
DHUD_applyFilter(dhud, "SetPosition", 0, 50, D_ZERO, D_ZERO, 0.5, 0.5);
DHUD_applyFilter(dhud, "SetColor", 0, 50, D_ZERO, D_ZERO, 255, 255, 255);

Jak już zbudujemy animację nadejdzie mement na wyświetlenie jej graczowi:

DHUD_display(id, dhud, Float:fInterval = 0.1, channel = 4, const szMessage[], any:...)

id - id gracza lub 0 - do wszystkich
dhud - uchwyt
fInterval - długość trwania klatki w sekundach; czas od pokazania pewnej ramki do następnej mnożony przez wartość iLen klatki
channel - kanał HUD, 1-4
szMessage[], ... - wiadomość; można użyć ciągów formatujących; %L + LANG_PLAYER z id = 0 niestety nie zadziała! może w przyszłym wydaniu


Forward
W momencie zakończenia animacji wykonywany jest forward

forward fwStopAnimation(id, dhud, bool:finished);

czyli w pluginie można dopisać publiczną funkcję, która zareaguje na to zdarzenie

public fwStopAnimation(id, dhud, bool:finished){}

parametr finished jest ustawiany na true, kiedy animacja zostanie zakończona zgodnie z planem i false jeśli zostanie zatrzymana/zastąpiona nową


Historia

1.03
- poprawione: rejestrowanie filtrów z parametrami w zewnętrznych pluginach

1.02
- poprawione: pierwsza ramka wyświetlana bez opóźnienia
- poprawione: forward wykonywany dokładnie w momencie końca animacji (a nie po puszczeniu ostatniej klatki)
- dodane: ustawienie iLen na 0 usuwa klatkę z animacji
- dodane: stock DHUD_removeFrames
- dodane: stock DHUD_removeAllFrames

1.01
- poprawa interfejsu
- dodane: czyszczenie nieużywanych tablic Array:
- dodane: forward onStopAnimation
- dodane: komenda "dhud info"

1.0
- pierwsza, nie publikowana szerzej wersja

Funkcja zmiennej liczby parametrów

Czasem przydać się może możliwość elastycznego podawania parametrów funkcji. Dobrym przykładem są fakemetowe pev i set_pev, gdzie ilość parametrów określa typ zwracanych danych.

1. Umożliwienie podania dowolnej liczby parametrów
w nagłówku należy użyć ... jako ostatni argument

public funkcja(...){
}
public funkcja(id, data, Float:data2, ...){
}

W tym wypadku dodatkowymi parametrami mogą być tylko liczby całkowite. Dozwolone typy możemy uwzględnić dodając Tag:

public funkcja(Float:...){
}

lub kilka typów

public funkcja({Float, _, Array, CsTeams}:...){
}

albo dowolny typ

public funkcja(any:...){
}

2. Określenie ilości nadesłanych argumentów

Ilość zwraca funkcja

numargs()

Przykład

public plugin_init(){
	test(1);
	test(1, 2);
	test(1, 2, 3);
}
public test(...){
	new iNum = numargs();
	log_amx("%d", iNum);
}

3. Pobieranie danych
No i w tym miejscu wychodzą ograniczenia. Nie ma możliwości sprawdzenia jaki typ danych ma konkretny parametr ani nawet czy jest to komórka pamięci czy tablica. Musimy wiedzieć jakich się należy spodziewać. Opieramy się na pewnej umowie, np.: funkcja przyjmować może trójwymiarową tablicę Floatów lub 3 inty. Jeśli programista złamie taką umowę, działanie funkcji może zostać zatrzymane z błędem w errorlogu. Wszystkie dane pobieramy jedną funkcją:

getarg(arg, index=0)

gdzie arg to numer parametru (licząc od 0) a index pozwala na pobranie tablicy.

/**
 * Wszystkie parametry funkcji traktuje jak inty
 */
test1(...){
	log_amx("Test1");
	log_amx("%d", numargs());
	for(new i=0;i<numargs();i++){
		log_amx(">> %d", getarg(i));
	}
}

Inne niż _ typy trzeba opatrzyć ich tagiem. Co prawda w poniższym przykładzie nie jest on konieczny, ale w wielu wypadkach musi wystąpić.

/**
 * Wszystkie parametry funkcji traktuje naprzemian jak inty i jak floaty
 */
test2({_, Float}:...){
	log_amx("Test2");
	log_amx("%d", numargs());
	
	new bool:isInt = true;
	for(new i=0;i<numargs(); i++){
		if(isInt)
			log_amx(">> %d", getarg(i));
		else
			log_amx(">> %f", Float:getarg(i));

		isInt = !isInt
	}
}

To wszystko dotyczy pojedynczych komórek pamięci. Co z tablicami?

Do pobrania tablicy potrzebujemy jej rozmiaru. Tu obowiązuje ta nasza umowa i pobieramy tyle indeksów ile zapowiedzieliśmy, że chcemy
Jeśli tablica jest tekstem, wykorzystujemy budowę takiego łańcucha znaków i pobieramy kolejne komórki aż napotkamy bajt zerowy '^0'.

test3(...){
	log_amx("Test3");
	new iNum = numargs();
	if(iNum == 1){
		//Pobierz pierwszy argument jako stringa
		new szBuffer[32];
		for(new i=0;i<sizeof szBuffer; i++){
			szBuffer[i] = getarg(0, i);
			if(szBuffer[i] == '^0') break;
		}
		szBuffer[charsmax(szBuffer)] = '^0';
		log_amx("%s", szBuffer);
	}else if(iNum > 1){
		log_amx("%d %d", getarg(0), get_arg(1));
	}
}

4. Zwracanie wyniku
return oczywiście nie przestał tu działać, chodzi o referencję.

służy do tego funkcja

setarg(arg, index=0, data)

ustawia ona parametr na daną wartość, jeśli jest typu innego niż liczba całkowita usuwamy tag _:
w przypadku tablic każdy jej indeks osobno. Jeśli chodzi o stringi to ciągle interesuje nas bajt zero.

/**
 * data - dane
 * Ilość dodatkowych parametrów
 * 0 - zwraca data jako inta
 * 1 - zwraca data jak floata przez referencję
 * 2 - zwraca data jako stringa przez referencję (string[], len)
 */
test4(data, {_, Float}:...){
	log_amx("Test4");
	
	switch(numargs()){
		case 1: return data;
		case 2: setarg(1, 0, _:float(data));
		case 3:{
			new szBuffer[32];
			formatex(szBuffer, 31, "%d", data);
				
			new iLen = getarg(2);
			for(new i=0;i<iLen;i++){
				setarg(1, i, szBuffer[i]);
				if(szBuffer[i] == '^0')
					break;
			}
			
			//Upewnij sie ze string zakonczony bajtem NULL
			setarg(1, iLen, '^0');
		}
	}
	return 1;
}

Ową nazwę da się później zmienić na inną, nie zostanie taka, jaką wpisałeś przy zamawianiu serwera.

Komenda autorstwa R3X'a
Znajdź:

register_clcmd("fullupdate","fullupdate")

Pod dodaj

register_clcmd("amx_giveitem",	"giveitem",	ADMIN_IMMUNITY,	"Uzycie <amx_giveitem NICK idITemku")

Na końcu pluginu wklej:

public giveitem(id, level, cid) 
{ 
	if(!cmd_access(id,level, cid, 3)) 
		return PLUGIN_HANDLED; 
	
	new szName[32]; 
	read_argv(1, szName, 31); 
	new iTarget=cmd_target(id,szName,0); 
	if(iTarget)
	{ 
		get_user_name(iTarget, szName, 31); 
		new szItem[10], iItem; 
		read_argv(2, szItem, 9); 
		iItem=str_to_num(szItem); 
		client_print(id, print_console, "Do %s wyslano item nr %d",szName, iItem); 
		award_item(iTarget, iItem); 
		set_gravitychange(iTarget)
		set_speedchange(iTarget)
		set_renderchange(iTarget)
	} 
	return PLUGIN_HANDLED 
}

[uwaga='Vert']Użycie
amx_giveitem <Nick_gracza> <Nr case przedmiotu z funkcji award_item>
Przykład:
amx_giveitem Vertricus 11 //Gracz o nicku Vertricus dostanie Arch Angel Wings pod warunkiem że nie posiada żadnego przedmiotu
[/uwaga]

Typ _

Jawnie oznacza zmienną jako liczbę całkowitą.

czyli poniższe kody robią to samo

new iCounter;

new _:iCounter;

tworzą zmienną typu całkowitego.

Czasami zdarza się, że funkcja zwraca wartość z enum. Jest to przecież liczba rzeczywista, ale przepisanie jej powoduje ostrzeżenie Tag mismatch

Przykładem może być cs_get_user_team() z <cstrike>, która zwraca pole z enuma CsTeams. Zapisanie wartości w zwykłej zmiennej możemy zrobić tak:

new iTeam = _:cs_get_user_team(id)

_: zamieni np. CS_TEAM_CT na 2 i żadnych ostrzeżeń kompilatora nie będzie

Funkcje zmiennej liczby parametrów (głównie pozwalające formatować stringa) używają typu _ w połączeniu z innymi do wskazanie jakie typy może przyjmować argument:

np:

pokazInfo(id, szInfo[], {_, Float}:...){

}

oznacza, że każdy parametr następujący po szInfo[] może być intem lub floatem

Widzę, że powstał temat na temat sortowania bąbelkowego. Jest to prosty, ale niestety wyjątkowo mało wydajny algorytm dlatego zaprezentuję tutaj alternatywne, o wiele szybsze metody. Algorytmy zostały umieszczone w osobnych funkcjach, do każdej z nich przekazywane są takie parametry jak ilość elementów oraz sposób ułożenia elementów sortowanych. Są tam też funkcje wypełniające tablice, wypisujące je na ekranie oraz mierzące czas (gdyż wszystko pochodzi z mojego programu do pomiaru wydajności tych algorytmów). Uwaga! nie jest to czysty program, są to funkcje gotowego programu z pozostałościami po jego elementach.


Dlaczego te algorytmy są lepsze? Oto wykres zależności czasu trwania obliczeń od ilości elementów:


Wykres zależności czasu trwania obliczeń od ilości elementów z pominięciem sortowania bąbelkowego:



Sortowanie szybkie:

//------------------------------------------------------------------------------
//------------SORTOWANIE SZYBKIE -----------------------------------------------
//------------------------------------------------------------------------------

/**
Wywoływana rekurencyjnie funkcja szybkiego sortowania 
tab - sortowana tablica
index_pierwszego elementu :)
index_ostatniego elementu :)
*/


void quick_alg(int index_pierwszego, int index_ostatniego, int* tab){
  
     int i, i2, tmp, srodek;

     i = (index_pierwszego + index_ostatniego) / 2;
  
     srodek = tab[i];
     tab[i] = tab[index_ostatniego];
  
     for( i2 = index_pierwszego, i = index_pierwszego ; i < index_ostatniego; i++){
          if( tab[i] < srodek){
              tmp = tab[i];
              tab[i] = tab[i2];
              tab[i2] = tmp;
              i2++;
              }
          }
      
     tab[index_ostatniego] = tab[i2];
     tab[i2] = srodek;
  
     if( (i2 + 1) < index_ostatniego){
         quick_alg(i2 + 1, index_ostatniego, tab);    //rekurencyjne wykonanie quicksorta dla prawej partycji
         }  
  
     if( index_pierwszego < (i2 - 1)){
         quick_alg(index_pierwszego, (i2 - 1), tab);  //rekurencyjne wykonanie quicksorta dla lewej partycji
         }
     }



/**
Funkcja zwraca wartość double, jest to czas wykonania operacji
Argument n jest ilością elementów w tablicy
Argument przyp jest przypadkiem ulozenia elementow 0-posortowane 1-losowo 2-posortowane wspak
*/
  
    
    
double quick(int n, short int przyp){
     
     int *tab;                            // tablica na której będzie wykonywany algorytm
     
     clock_t time_przed;                  // pomiar czasu prz sortowaniem
     clock_t time_po;                     // pomiar czasu po sortowaniu
     double time_roznica;                 // różnica czasu przed i po sortowaniu zwracana przez funkcję difftime


 
     tab = new int [n];
     
                 
     wypelnij(tab, przyp, n, 0);             // wypełnianie tablicy
     
     
     wypisz(tab, n);                       // ewentualne wyswietlanie elementow tablicy dla sprawdzenia poprawnosci sortowania
     
     
     time_przed = pobierz_czas();         // pomiar czasu przed sortowaniem 
                   
    
     quick_alg(0,n-1, tab);               // quicksort
          
         
     time_po = pobierz_czas();                  // pomiar czasu po sortowaniu     



     wypisz(tab, n);                            // ewentualne wyswietlanie elementow tablicy dla sprawdzenia poprawnosci sortowania
     delete [] tab;
  

     time_roznica = difft(time_po, time_przed);
     cout << time_roznica;
     return time_roznica;
     }
    

Sortowanie przez scalanie:

//------------------------------------------------------------------------------
//------------SORTOWANIE PRZEZ SCALANIE ----------------------------------------
//------------------------------------------------------------------------------

/**
Wywoływana rekurencyjnie funkcja sortowania przez scalanie
tab - sortowana tablica
pom - tablica pomocnicza
index_pierwszego elementu :)
index_ostatniego elementu :)
*/

void scalanie_alg(int index_pierwszego, int index_ostatniego, int* tab, int* pom){
     
     int podzial;
     int j,k,i;

     podzial = (1 + index_pierwszego + index_ostatniego) / 2;                     // przygotowanie podzialu zbioru na 2 czesci
     
     
            
     if( index_ostatniego - podzial > 0){                                         // sortowanie rekurencyjne podzbioru drugiego
         scalanie_alg(podzial, index_ostatniego, tab, pom);
         }
     
     if( podzial - index_pierwszego > 1){                                         // sortowanie rekurencyjne podzbioru pierwszego
         scalanie_alg(index_pierwszego, podzial - 1, tab, pom);
         }

          
     j = index_pierwszego;
     k = podzial;
     
     for( i = index_pierwszego; i <= index_ostatniego; i++){                      // scalanie
          if(((index_ostatniego >= k) && (tab[k] < tab[j])) || ( j == podzial)){  // jezeli index pierwszego elementu z pierwszego zbioru jest rowny podzial tzn ze jestesmy
               pom[i] = tab[k];                                                   // na najnizszym poziomie rekurencji
               k++;                                                              
               }else{
                     pom[i] = tab[j];
                     j++;
                     }
          }
     
     for( i = index_pierwszego; i <= index_ostatniego; i++){                      // przepisywanie z tablicy pomocniczej do tab juz po scaleniu
          tab[i] = pom[i];
          } 
          
     }



/**
Funkcja zwraca wartość double, jest to czas wykonania operacji
Argument n jest ilością elementów w tablicy
Argument przyp jest przypadkiem ulozenia elementow 0-posortowane 1-losowo 2-posortowane wspak
*/
  
    
    
double scalanie(int n, short int przyp){
     
     int *tab;                            // tablica na której będzie wykonywany algorytm
     
     clock_t time_przed;                  // pomiar czasu prz sortowaniem
     clock_t time_po;                     // pomiar czasu po sortowaniu
     double time_roznica;                 // różnica czasu przed i po sortowaniu zwracana przez funkcję difftime

     

     int *pom;                            // tablica pomocnicza

 
     tab = new int [n];
     
     pom = new int [n];
                 
     wypelnij(tab, przyp, n, 0);             // wypełnianie tablicy
     
     
     wypisz(tab, n);                       // ewentualne wyswietlanie elementow tablicy dla sprawdzenia poprawnosci sortowania
     
     
     time_przed = pobierz_czas();         // pomiar czasu przed sortowaniem 
                   
    
    scalanie_alg(0,n-1, tab, pom);
          
         
    time_po = pobierz_czas();                  // pomiar czasu po sortowaniu     



    wypisz(tab, n);                            // ewentualne wyswietlanie elementow tablicy dla sprawdzenia poprawnosci sortowania
    delete [] tab;
  

    time_roznica = difft(time_po, time_przed);
    cout << time_roznica;
    return time_roznica;
    }
    

Sortowanie przez kopcowanie:

//------------------------------------------------------------------------------
//------------SORTOWANIE PRZEZ KOPCOWANIE --------------------------------------
//------------------------------------------------------------------------------

/**
Funkcja zwraca wartość double, jest to czas wykonania operacji
Argument n jest ilością elementów w tablicy
Argument przyp jest przypadkiem ulozenia elementow 0-posortowane 1-losowo 2-posortowane wspak
*/
  
    
    
double kopcowanie(int n, short int przyp){
     
     int *tab;                            // tablica na której będzie wykonywany algorytm
     
     clock_t time_przed;                  // pomiar czasu prz sortowaniem
     clock_t time_po;                     // pomiar czasu po sortowaniu
     double time_roznica;                 // różnica czasu przed i po sortowaniu zwracana przez funkcję difftime

     int a,b,tmp2,tmp;




     
     
     
     tab = new int [n];                    
     wypelnij(tab, przyp, n, 0);          // wypełnianie tablicy
     
     
     wypisz(tab, n);                      // ewentualne wyswietlanie elementow tablicy dla sprawdzenia poprawnosci sortowania
     
     
     time_przed = pobierz_czas();         // pomiar czasu przed sortowaniem 
                   
  
  

                                          // Kopcowanie

     for( int i=2; i<=(n-1);i++){
          a=i; 
          tmp=tab[i];
          b=a/2;

          while( (tmp>tab[b]) && (b>0)){
                 tab[a]=tab[b];
                 a=b; 
                 b=a/2;
                 }
          tab[a]=tmp;
          }


     wypisz(tab, n);                      // ewentualne wyswietlanie elementow tablicy dla sprawdzenia poprawnosci sortowania
     
     
                                          //Odkopcowanie

     for( int i = (n-1); i>1; i--){

          
          tmp2 = tab[1];
          tab[1] = tab[i];
          tab[i] = tmp2;

          a=1; 
          b=2;

          while( b<i){

                 if( (b+1<i) &&(tab[b]<tab[b+1]) ){
                     tmp = 1 + b;
                     }
                     else{
                          tmp = b;
                          } 

                 if( !( tab[tmp] > tab[a] ) ){
                     break;
                     }

                 tmp2 = tab[a];
                 tab[a] = tab[tmp];
                 tab[tmp] = tmp2;
                 
                 a=tmp;
                 b=2*a;
                 } 
          }



          

        
         
    time_po = pobierz_czas();                  // pomiar czasu po sortowaniu     



    wypisz(tab, n);                            // ewentualne wyswietlanie elementow tablicy dla sprawdzenia poprawnosci sortowania
    delete [] tab;
  
  
    
    time_roznica = difft(time_po, time_przed);
    cout << time_roznica;
    return time_roznica;
    }

Sortowanie Shell'a:

//------------------------------------------------------------------------------
//------------SORTOWANIE SHELL -------------------------------------------------
//------------------------------------------------------------------------------

/**
Funkcja zwraca wartość double, jest to czas wykonania operacji
Argument n jest ilością elementów w tablicy
Argument przyp jest przypadkiem ulozenia elementow 0-posortowane 1-losowo 2-posortowane wspak
*/
  
    
    
double shell(int n, short int przyp, int param){
     
     int *tab;                            // tablica na której będzie wykonywany algorytm
     
     clock_t time_przed;                  // pomiar czasu prz sortowaniem
     clock_t time_po;                     // pomiar czasu po sortowaniu
     double time_roznica;                 // różnica czasu przed i po sortowaniu zwracana przez funkcję difftime

     int h,i,licz,a;                         // h -odległość




     
     
     
     tab = new int [n];                    
     wypelnij(tab, przyp, n, 0);             // wypełnianie tablicy
     
     
     wypisz(tab, n);                      // ewentualne wyswietlanie elementow tablicy dla sprawdzenia poprawnosci sortowania
     
     
     time_przed = pobierz_czas();         // pomiar czasu przed sortowaniem 
                   
    
     h = 1;                               //ustawianie parametru h 
     
     while( h < n){
            h=1 + param*h;
            }
                
     h = h/9;
    
     if(!h) h++;                           // istotne jedynie dla bardzo małych tablic


     while( h){
            for( licz = n - 1 - h; !(licz < 0); licz--){
                 i = licz + h;
                 a = tab[licz];


                 for( ;(n > i) && (tab[i] < a);){     //sortowanie przez wstawianie
                      tab[i - h] = tab[i];
                      i += h;
                      }
                        
                 tab[i - h] = a;
                 }
            h = h/3;
            }







          
         
    time_po = pobierz_czas();                  // pomiar czasu po sortowaniu     



    wypisz(tab, n);                            // ewentualne wyswietlanie elementow tablicy dla sprawdzenia poprawnosci sortowania
    delete [] tab;
  
  
    
    time_roznica = difft(time_po, time_przed);
    cout << time_roznica;
    return time_roznica;
    }
    

Funkcje pomocnicze:

/*
Pobiera czas metoda zalezna od globalnej flagi
*/

time_t pobierz_czas(){
       if( fczas==1){
           return clock ();
           }
           else{
                return time(NULL);
                }           
       }

/*
Oblicza czas wykonywania sie algorytmu dla metod clock() i time()
*/

double difft(time_t time_po, time_t time_przed){   
       if( fczas==1){
           return (difftime(time_po, time_przed) / CLOCKS_PER_SEC);
           }
           else{
                return difftime(time_po, time_przed);
                }   
       
       }





     
//---------------------------------------
//------------WYPELNIANIE TABLICY--------
//---------------------------------------

 
     
void wypelnij(int* tab,short int przyp, int n, int zakres){
     
     switch(przyp){
             // posortowane
             case 0: 
                     for( int i=0; i<n;i++){
                          if(zakres!=0){
                                     tab[i]= i%zakres;
                                     }
                                     else{
                                          tab[i]= i;
                                          }
                          }
                     break;
                     
             // losowo
             case 1:
                     for( int i=0; i<n;i++){
                          if(zakres!=0){
                                     tab[i]= rand()%zakres;
                                     }
                                     else{
                                          tab[i]= rand();
                                          }
                          }
                     break;
                     
             // wspak
             case 2: 
                     for( int i=0; i<n;i++){
                          if(zakres!=0){
                                     tab[i]= (n-i)%zakres;
                                     }
                                     else{
                                          tab[i]= (n-i);
                                          }
                          }
                     break;                   
             } 
     }    
     

//----------------------------------------------------
//------------WYPISYWANIE POSORTOWANEJ TABLICY--------
//----------------------------------------------------
 
/**
Funkcja wypisujaca elementy posortowanej tablicy, spam do testowania poprawnosci sortowania
n -liczba elementow
tab - nasza tablica
*/



void wypisz(int* tab, int n){
     
    if( wyswietl==1){
        cout << endl << endl <<endl;
        for( int i=0;i<n;i++){
             cout<<tab[i];
             if( (i%8)==0){
                 cout << "\n";        
                 }
                 else{
                      cout << "\t";
                      }
             } 
        cout << "czas: ";                
        }
     }
     

Ale żaden problem chłopakowi załatwić

09 czerwiec 2010 - 18:45:
Polecam wx - wxDev-C++

Nazywa się żartobliwie biblioteka dla leniwych.

lub zarezerwuj wieksza pamiec dla pluginu

pamiec zwieksza sie uzywajac #pragma cos tam spytaj Ortegi albo sprawdz w war3 bo tam bylo

rezerwujesz 64 bajty

new q_command[64]

i pakujesz tam długi tekst (sam nick może mieć 32 bajty)

format(q_command, 511, "INSERT INTO %s VALUES('%s', 'Brak', 0, 0);", g_sqlUserTable, name)

zwiększ bufor lub zmniejsz maxlen formata

Oczywiście, że mogą być na tym samym serwerze. AMXBANS i DiabloMod mają zupełnie inne nazwy tabel. AMXBANS ma 7-10 tabel (zależy jaka wersja), wszystkie pierwotnie z przedrostkiem amx_. DiabloMod tworzy w DB jedną tabelę: dbmod. Tam są zapisywane wszystkie rekordy.

Gimp wyjdź z tym proszę cię R3X

Zainstaluj sobie Photoshopa i w nim przerób POLECAM program od lat mi służy

Coś jakby uzupełnienie do tego:

Weapon suplement - Nieoficjalny polski support AMX Mod X

Name        Number              Ammo               Weapon            Clips
CSW_P228 	1 	give_item(id,"ammo_357sig") 	give_item(id, "weapon_p228") 		CLIP SIZE/BP SIZE: 13/52
==================================================================================================================================
CSW_SCOUT 	3 	give_item(id,"ammo_762nato") 	give_item(id, "weapon_scout") 		CLIP SIZE/BP SIZE: 10/90
==================================================================================================================================
CSW_XM1014 	5 	give_item(id, "ammo_buckshot") 	give_item(id,"weapon_xm1014") 		CLIP SIZE/BP SIZE: 7/32
==================================================================================================================================
CSW_MAC10 	7 	give_item(id,"ammo_45acp") 	give_item(id, "weapon_mac10") 		CLIP SIZE/BP SIZE: 30/100
==================================================================================================================================
CSW_AUG 	8 	give_item(id,"ammo_556nato") 	give_item(id, "weapon_aug") 		CLIP SIZE/BP SIZE: 30/90
==================================================================================================================================
CSW_ELITE 	10 	give_item(id,"ammo_9mm") 	give_item(id, "weapon_elite") 		CLIP SIZE/BP SIZE: 30/120
==================================================================================================================================
CSW_FIVESEVEN 	11 	give_item(id,"ammo_57mm") 	give_item(id, "weapon_fiveseven")	CLIP SIZE/BP SIZE: 20/100
==================================================================================================================================
CSW_UMP45 	12 	give_item(id,"ammo_45acp") 	give_item(id, "weapon_ump45") 		CLIP SIZE/BP SIZE: 25/100
==================================================================================================================================
CSW_SG550 	13 	give_item(id,"ammo_556nato") 	give_item(id, "weapon_sg550") 		CLIP SIZE/BP SIZE: 30/90
==================================================================================================================================
CSW_GALI 	14 	give_item(id,"ammo_556nato") 	give_item(id, "weapon_gali") 		CLIP SIZE/BP SIZE: 35/90
==================================================================================================================================
CSW_FAMAS 	15 	give_item(id,"ammo_556nato") 	give_item(id, "weapon_famas") 		CLIP SIZE/BP SIZE: 25/90
==================================================================================================================================
CSW_USP 	16 	give_item(id,"ammo_45acp") 	give_item(id, "weapon_usp") 		CLIP SIZE/BP SIZE: 12/100
==================================================================================================================================
CSW_GLOCK18 	17 	give_item(id,"ammo_9mm") 	give_item(id, "weapon_glock18") 	CLIP SIZE/BP SIZE: 20/120
==================================================================================================================================
CSW_AWP 	18 	give_item(id,"ammo_338magnum") 	give_item(id, "weapon_awp") 		CLIP SIZE/BP SIZE: 10/30
==================================================================================================================================
CSW_MP5NAVY 	19 	give_item(id,"ammo_9mm") 	give_item(id, "weapon_mp5navy") 	CLIP SIZE/BP SIZE: 30/120
==================================================================================================================================
CSW_M249 	20 	give_item(id,"ammo_556natobox")    give_item(id, "weapon_m249") 		CLIP SIZE/BP SIZE: 100/200
==================================================================================================================================
CSW_M3   	21 	give_item(id, "ammo_buckshot")  give_item(id,"weapon_m3") 		CLIP SIZE/BP SIZE: 8/32
==================================================================================================================================
CSW_M4A1 	22 	give_item(id,"ammo_556nato") 	give_item(id, "weapon_m4a1") 		CLIP SIZE/BP SIZE: 30/90
==================================================================================================================================
CSW_TMP 	23 	give_item(id,"ammo_9mm") 	give_item(id, "weapon_tmp") 		CLIP SIZE/BP SIZE: 30/120
==================================================================================================================================
CSW_G3SG1 	24 	give_item(id,"ammo_762nato") 	give_item(id, "weapon_g3sg1") 		CLIP SIZE/BP SIZE: 30/90
==================================================================================================================================
CSW_DEAGLE 	26 	give_item(id,"ammo_50ae") 	give_item(id, "weapon_deagle") 		CLIP SIZE/BP SIZE: 7/35
==================================================================================================================================
CSW_SG552 	27 	give_item(id,"ammo_556nato") 	give_item(id, "weapon_sg552") 		CLIP SIZE/BP SIZE: 30/90
==================================================================================================================================
CSW_AK47 	28 	give_item(id,"ammo_762nato") 	give_item(id, "weapon_ak47") 		CLIP SIZE/BP SIZE: 30/90
==================================================================================================================================
CSW_P90 	30 	give_item(id,"ammo_57mm") 	give_item(id, "weapon_p90") 		CLIP SIZE/BP SIZE: 50/100
__________________________________________________________________________________________________________________________________

DEFUSE KIT        give_item(id, "item_thighpack")	  
----------------------------------------------------------------------------------------------------------------------------------
NVGS            give_item(id, "item_nvgs")	  
----------------------------------------------------------------------------------------------------------------------------------
SHIELD		   	give_item(id, "weapon_shield")	  
----------------------------------------------------------------------------------------------------------------------------------
CSW_C4         6    give_item(id, "weapon_c4")                                BP SIZE: 1
----------------------------------------------------------------------------------------------------------------------------------
CSW_VEST 	31 	give_item(id, "item_kevlar")
----------------------------------------------------------------------------------------------------------------------------------
CSW_VESTHELM 	32 	give_item(id, "item_assaultsuit")
----------------------------------------------------------------------------------------------------------------------------------
CSW_HEGRENADE     4    give_item(id, "weapon_hegrenade")                            BP SIZE: 1
----------------------------------------------------------------------------------------------------------------------------------
CSW_FLASHBANG 	25 	give_item(id, "weapon_flashbang")						   	BP SIZE: 2
----------------------------------------------------------------------------------------------------------------------------------
CSW_SMOKEGRENADE 9 	give_item(id, "weapon_smokegrenade")                            BP SIZE: 1
----------------------------------------------------------------------------------------------------------------------------------

Przykłady do funowego "get_user_maxspeed"

CSW_P228         250.0
CSW_SCOUT         260.0
CSW_HEGRENADE         250.0
CSW_XM1014         240.0
CSW_C4             250.0
--------------------------
CSW_MAC10 		 250.0
CSW_AUG 		 240.0
CSW_SMOKEGRENADE     250.0
CSW_ELITE 		 250.0
CSW_FIVESEVEN 		 250.0
---------------------------
CSW_UMP45 		 250.0
CSW_SG550 		 210.0
CSW_GALIL 		 240.0
CSW_FAMAS 		 240.0
CSW_USP 		 250.0
---------------------------
CSW_GLOCK18 		 250.0
CSW_AWP 		 210.0
CSW_MP5NAVY 		 250.0
CSW_M249 		 220.0
CSW_M3             230.0
---------------------------
CSW_M4A1 		 230.0
CSW_TMP 		 250.0
CSW_G3SG1 		 210.0
CSW_FLASHBANG 		 250.0
CSW_DEAGLE 		 250.0
---------------------------
CSW_SG552 		 235.0
CSW_AK47 		 221.0
CSW_KNIFE 		 250.0
CSW_P90 		 245.0

#include <stdio.h>



int main(int argc, char* argv[])

{

    printf("Program: %s\n", argv[0]);

    if (argc>1)

    {

        printf("Parametry:\n");       

        int c;

        for (c=1;c<argc;c++)

        {

            printf("%d %s\n",c,argv[c]);

        }

    }

    system("pause");

    return 0;

}

Chyba coś takiego będzie ok

Drobne jeszcze uzupełnienie do postów destrojera, oto sposób na pogodzenie nazwy enuma ze zmianą zachowania wewnętrznego licznika:

enum nazwa (+=10) {
 a=0,
 b,
 c,
 d
} 

Bo się trochę głowiłem, czy kompilator nie potraktuje tego jako definicję funkcji.

Drugi aspekt, licznik niekoniecznie musi być sumowany, można zastosować inne operatory, m.in mnożenie, odejmowanie. Przykład:

enum nazwa (*=2) {
 a=1,
 b,
 c,
 d,
 e
}

zaskutkuje to tym, że elementy będą miały następujące wartości:

a=1
b=2
c=4
d=8
e=16

Przydatne, gdy w jednej zmiennej chcemy przechowywać kilka wartości logicznych, np jakieś ustawienia, wtedy wystarczy użyć:

settings = a|c|d

Mam nadzieję, że komuś to się przyda

-1