#include <amxmodx>
#include <amxmisc>
#include <cstrike>
#include <fakemeta>
#include <hamsandwich>
#include <fun>
#include <nvault>
#include <codmod>
#include <colorchat>
 
#define PLUGIN "Call of Duty: MW Mod"
#define VERSION "1.0-3"
#define AUTHOR "QTM_Peyote edit. Qazz"
 
#define MAX_WIELKOSC_NAZWY 32
#define MAX_WIELKOSC_OPISU 256
#define MAX_ILOSC_PERKOW 120
#define MAX_ILOSC_KLAS 100
 
#define STANDARDOWA_SZYBKOSC 250.0
 
#define ZADANIE_POKAZ_INFORMACJE 672
#define ZADANIE_POKAZ_REKLAME 768
#define ZADANIE_USTAW_SZYBKOSC 832
 
#define MAX_WIELKOSC_FRAKCJA 64
#define MAX 32
#define IsPlayer(%1) (1 <= %1 <= MAX && is_user_connected(%1))
 
#define NE_UA_VERSION "1.0.1"
#define MONETY
 
#if !defined MONETY
new money_sell;
#else
new coins_sell;
#endif
 
#if defined MONETY
native cod_get_user_coins(id);
native cod_set_user_coins(id, wartosc);
#endif
 
#define MAX_WIELKOSC_FRAKCJA 64
new frakcja_klas[MAX_ILOSC_KLAS+1][MAX_WIELKOSC_FRAKCJA+1];
new nazwa_klasy[MAX_ILOSC_KLAS+1][64];
new nazwa_frakcji[MAX_ILOSC_KLAS+1][64];
new klasid;
 
new const maxAmmo[31] = {0, 52, 0, 90, 1, 31, 1, 100, 90, 1, 120, 100, 100, 90, 90, 90, 100, 120, 30, 120, 200, 31, 90, 120,
90, 2, 35, 90, 90,0, 100};
 
new MsgScreenfade;
 
new vault;
 
new SyncHudObj, SyncHudObj2;
 
new cvar_doswiadczenie_za_zabojstwo,
cvar_doswiadczenie_za_obrazenia,
cvar_doswiadczenie_za_wygrana,
cvar_typ_zapisu,
cvar_limit_poziomu,
cvar_proporcja_poziomu,
cvar_blokada_broni;
 
 
new perk_zmieniony,
klasa_zmieniona;
 
 
new nazwy_perkow[MAX_ILOSC_PERKOW+1][MAX_WIELKOSC_NAZWY+1],
opisy_perkow[MAX_ILOSC_PERKOW+1][MAX_WIELKOSC_OPISU+1],
max_wartosci_perkow[MAX_ILOSC_PERKOW+1],
min_wartosci_perkow[MAX_ILOSC_PERKOW+1],
pluginy_perkow[MAX_ILOSC_PERKOW+1],
ilosc_perkow;
 
 
new nazwa_gracza[33][64],
klasa_gracza[33],
nowa_klasa_gracza[33],
poziom_gracza[33],
doswiadczenie_gracza[33],
perk_gracza[2] [33],
wartosc_perku_gracza[2] [33];
 
new Float:maksymalne_zdrowie_gracza[33],
Float:szybkosc_gracza[33],
Float:redukcja_obrazen_gracza[33],
Float:wartosc_grawitacji_gracza[33];
 
new punkty_gracza[33],
zdrowie_gracza[33],
inteligencja_gracza[33],
wytrzymalosc_gracza[33],
kondycja_gracza[33],
grawitacja_gracza[33];
 
new bool:gracz_ma_tarcze[33],
bool:gracz_ma_noktowizor[33];     
 
new bonusowe_bronie_gracza[33],
bonusowe_zdrowie_gracza[33],
bonusowa_inteligencja_gracza[33],
bonusowa_wytrzymalosc_gracza[33],
bonusowa_kondycja_gracza[33],
bonusowa_grawitacja_gracza[33];
 
new bronie_klasy[MAX_ILOSC_KLAS+1], 
zdrowie_klas[MAX_ILOSC_KLAS+1],
kondycja_klas[MAX_ILOSC_KLAS+1], 
inteligencja_klas[MAX_ILOSC_KLAS+1], 
wytrzymalosc_klas[MAX_ILOSC_KLAS+1],
grawitacja_klas[MAX_ILOSC_KLAS+1],
nazwy_klas[MAX_ILOSC_KLAS+1][MAX_WIELKOSC_NAZWY+1],
opisy_klas[MAX_ILOSC_KLAS+1][MAX_WIELKOSC_OPISU+1],
pluginy_klas[MAX_ILOSC_KLAS+1],
ilosc_klas;
 
new bronie_druzyny[] = {0, 0, 0},
bronie_dozwolone = 1<<CSW_KNIFE | 1<<CSW_C4;
 
new bool:freezetime = true;
 
new awanse[MAX_ILOSC_KLAS+1][3], awansuje_do[MAX_ILOSC_KLAS+1], awansuje_z[MAX_ILOSC_KLAS+1];
 
new ilosc_awansow;
 
new g_iZemsta[MAX+1];
new bool:g_bAsysta[MAX+1][MAX+1];
 
new g_pCvarAsysta;
new g_pCvarZemsta;
 
 
new bool:dostal_przedmiot[33];
new oddaj_id[33];
 
new CSW_MAXAMMO[33]= {-2, 52, 0, 90, 1, 32, 1, 100, 90, 1, 120, 100, 100, 90, 90, 90, 100, 120, 30, 120, 200, 32, 90, 120, 90, 2, 35, 90, 90, 0, 100, -1, -1}
new cvar_enable
 
new premium_on
 
public plugin_init() 
{
   register_plugin(PLUGIN, VERSION, AUTHOR);
 
   cvar_doswiadczenie_za_zabojstwo = register_cvar("cod_killxp", "2300");
   cvar_doswiadczenie_za_obrazenia = register_cvar("cod_damagexp", "250"); // ilosc doswiadczenia za 20 obrazen 
   cvar_doswiadczenie_za_wygrana = register_cvar("cod_winxp", "5000");
   cvar_typ_zapisu = register_cvar("cod_savetype", "1");  // 1-Nick; 2-SID dla Steam; 3-IP
   cvar_limit_poziomu = register_cvar("cod_maxlevel", "4001"); 
   cvar_proporcja_poziomu = register_cvar("cod_levelratio", "10"); 
   cvar_blokada_broni = register_cvar("cod_weaponsblocking", "1"); 
   cvar_enable= register_cvar("ne_uammo_enable", "1")
 
   register_clcmd("say /klasa", "WybierzKlase");
   register_clcmd("say /class", "WybierzKlase");
   register_clcmd("say /klasy", "OpisKlasy");
   register_clcmd("say /classinfo", "OpisKlasy");
   register_clcmd("say /perk", "KomendaOpisPerku");
   register_clcmd("say /perki", "OpisPerkow");
   register_clcmd("say /perks", "OpisPerkow");
   register_clcmd("say /item", "Pomoc");
   register_clcmd("say /przedmiot", "OpisPerku");
   register_clcmd("say /drop", "WyrzucPerk");
   register_clcmd("say /wyrzuc", "WyrzucPerk");
   register_clcmd("say /reset", "KomendaResetujPunkty");
   register_clcmd("say /statystyki", "PrzydzielPunkty");
   register_clcmd("say /staty", "PrzydzielPunkty");
   register_clcmd("say /pomoc", "Pomoc");
   register_clcmd("say /evo", "funkcja_przyklad") 
   register_clcmd("say /awanseinf", "funkcja_abc")
   register_clcmd("say /daj", "OddajPerk");
   register_clcmd("say /daj2", "OddajPerk2");
   register_clcmd("say /oddaj", "OddajPerk");
   //register_clcmd("say /oddaj2", "OddajPerk2");   
   register_clcmd("useperk2", "UzyjPerku");
   register_clcmd("radio2", "UzyjPerku");
   register_clcmd("fullupdate", "BlokujKomende");
   register_clcmd("say /kup","premium")
   register_clcmd("say /premium","premium")
   register_clcmd("say /sprzedaj", "sprzedaj_perk");
   register_clcmd("say /sell", "sprzedaj_perk");
 
   #if !defined MONETY
   money_sell = register_cvar("cod_money_sellperk", "3000");
   #else
   coins_sell = register_cvar("cod_coins_sellperk", "2");
   #endif
 
   premium_on = register_cvar("premium_on","1")
   register_logevent("pokaz_info",2,"1=Round_Start")
 
   register_menucmd(register_menuid("Klasa:"), 1023, "OpisKlasy");
 
   RegisterHam(Ham_TakeDamage, "player", "Obrazenia");
   RegisterHam(Ham_TakeDamage, "player", "ObrazeniaPost", 1);
   RegisterHam(Ham_Spawn, "player", "Odrodzenie", 1);
   RegisterHam(Ham_Killed, "player", "SmiercGraczaPost", 1);
 
   RegisterHam(Ham_Touch, "armoury_entity", "DotykBroni");
   RegisterHam(Ham_Touch, "weapon_shield", "DotykTarczy");
   RegisterHam(Ham_Touch, "weaponbox", "DotykBroni");
 
   register_forward(FM_CmdStart, "CmdStart");
   register_forward(FM_EmitSound, "EmitSound");
 
 
   register_logevent("PoczatekRundy", 2, "1=Round_Start"); 
 
   register_event("SendAudio", "WygranaTerro" , "a", "2&%!MRAD_terwin");
   register_event("SendAudio", "WygranaCT", "a", "2&%!MRAD_ctwin");
   register_event("CurWeapon","CurWeapon","be", "1=1");
   register_event("HLTV", "NowaRunda", "a", "1=0", "2=0");
   register_event("ResetHUD", "cod_perk_changed", "abe");
   register_event("CurWeapon", "event_curweapon", "be", "1=1")
 
 
   g_pCvarAsysta = register_cvar("cod_xp_asysta", "1000");
   g_pCvarZemsta = register_cvar("cod_xp_zemsta", "3000");
 
   register_event("DeathMsg", "eventDeath", "a");
   register_event("HLTV", "newRound", "a", "1=0", "2=0") 
 
   RegisterHam(Ham_TakeDamage, "player", "fwDamage", 1);
 
   register_clcmd("say /perk2", "KomendaOpisPerku2");
   register_clcmd("say /drop2", "WyrzucPerk2");
   register_clcmd("say /wyrzuc2", "WyrzucPerk2");
   register_clcmd("useperk3", "UzyjPerku2");
   register_clcmd("radio3", "UzyjPerku2");
 
   vault = nvault_open("CodMod");
 
   MsgScreenfade = get_user_msgid("ScreenFade");
 
   SyncHudObj = CreateHudSyncObj();
   SyncHudObj2 = CreateHudSyncObj();
 
   perk_zmieniony = CreateMultiForward("cod_perk_changed", ET_CONTINUE, FP_CELL, FP_CELL, FP_CELL, FP_CELL);
   klasa_zmieniona = CreateMultiForward("cod_class_changed", ET_CONTINUE, FP_CELL, FP_CELL);
 
   copy(nazwy_perkow[0], MAX_WIELKOSC_NAZWY, "Brak");
   copy(opisy_perkow[0], MAX_WIELKOSC_OPISU, "Zabij kogos, aby otrzymac przedmiot");
   copy(nazwy_klas[0], MAX_WIELKOSC_NAZWY, "Brak");
 
   set_task(1.0, "plugin_cfg");
 
   loadfile()
}
 
public loadfile()
{
   new file[256];
   get_configsdir(file,charsmax(file));
   formatex(file, charsmax(file), "%s/cod_frakcje.ini", file);
 
   if(!file_exists(file))
      return;
 
   new row[128], trash,  size=file_size(file,1);
   for(new i=0;i<size;i++)
   {
      read_file(file, i, row, charsmax(row), trash);
 
      if((contain(row,";")!=0) && strlen(row) && klasid<MAX_ILOSC_KLAS+1)
      {
         replace(row, charsmax(row), "[klasa]", "");
         split(row, nazwa_klasy[klasid], charsmax(nazwa_klasy[]), nazwa_frakcji[klasid], charsmax(nazwa_frakcji[]), "[frakcja]");
         klasid++;
      }
   }    
}      
 
public plugin_cfg()
{
   new lokalizacja_cfg[33];
   get_configsdir(lokalizacja_cfg, charsmax(lokalizacja_cfg));
   server_cmd("exec %s/codmod.cfg", lokalizacja_cfg);
   server_exec();
}
 
 
public plugin_precache()
{   
   precache_sound("QTM_CodMod/select.wav");
   precache_sound("QTM_CodMod/start.wav");
   precache_sound("QTM_CodMod/start2.wav");
   precache_sound("QTM_CodMod/levelup.wav");
}
 
public plugin_natives()
{
   register_native("cod_set_user_xp", "UstawDoswiadczenie", 1);
   register_native("cod_set_user_class", "UstawKlase", 1);
   register_native("cod_set_user_perk", "UstawPerk", 1);
   register_native("cod_set_user_bonus_health", "UstawBonusoweZdrowie", 1);
   register_native("cod_set_user_bonus_intelligence", "UstawBonusowaInteligencje", 1);
   register_native("cod_set_user_bonus_trim", "UstawBonusowaKondycje", 1);
   register_native("cod_set_user_bonus_stamina", "UstawBonusowaWytrzymalosc", 1);
   register_native("cod_set_user_bonus_gravity", "UstawBonusowaGrawitacje", 1);
 
   register_native("cod_points_to_health", "PrzydzielZdrowie", 1);   
   register_native("cod_points_to_intelligence", "PrzydzielInteligencje", 1);   
   register_native("cod_points_to_trim", "PrzydzielKondycje", 1);   
   register_native("cod_points_to_stamina", "PrzydzielWytrzymalosc", 1);
   register_native("cod_points_to_gravity", "PrzydzielGrawitacje", 1);
 
   register_native("cod_get_user_xp", "PobierzDoswiadczenie", 1);
   register_native("cod_get_user_level", "PobierzPoziom", 1);
   register_native("cod_get_user_points", "PobierzPunkty", 1);
   register_native("cod_get_user_class", "PobierzKlase", 1);
   register_native("cod_get_user_perk", "PobierzPerk");
   register_native("cod_get_user_health", "PobierzZdrowie", 1);
   register_native("cod_get_user_intelligence", "PobierzInteligencje", 1);
   register_native("cod_get_user_trim", "PobierzKondycje", 1);
   register_native("cod_get_user_stamina", "PobierzWytrzymalosc", 1);
   register_native("cod_get_class_gravity", "PobierzGrawitacjeKlasy", 1);
 
   register_native("cod_get_level_xp", "PobierzDoswiadczeniePoziomu", 1);
 
   register_native("cod_get_perkid", "PobierzPerkPrzezNazwe", 1);
   register_native("cod_get_perks_num", "PobierzIloscPerkow", 1);
   register_native("cod_get_perk_name", "PobierzNazwePerku", 1);
   register_native("cod_get_perk_desc", "PobierzOpisPerku", 1);
 
   register_native("cod_get_classid", "PobierzKlasePrzezNazwe", 1);
   register_native("cod_get_classes_num", "PobierzIloscKlas", 1);
   register_native("cod_get_class_name", "PobierzNazweKlasy", 1);
   register_native("cod_get_class_desc", "PobierzOpisKlasy", 1);
 
   register_native("cod_get_class_health", "PobierzZdrowieKlasy", 1);
   register_native("cod_get_class_intelligence", "PobierzInteligencjeKlasy", 1);
   register_native("cod_get_class_trim", "PobierzKondycjeKlasy", 1);
   register_native("cod_get_class_stamina", "PobierzWytrzymaloscKlasy", 1);
 
   register_native("cod_give_weapon", "DajBron", 1);
   register_native("cod_take_weapon", "WezBron", 1);
   register_native("cod_set_user_shield", "UstawTarcze", 1);
   register_native("cod_set_user_nightvision", "UstawNoktowizor", 1);
 
   register_native("cod_inflict_damage", "ZadajObrazenia", 1);
 
   register_native("cod_register_perk", "ZarejestrujPerk");
   register_native("cod_register_class", "ZarejestrujKlase");
   register_native("cod_register_advance", "ZarejestrujAwans");
}
 
public CmdStart(id, uc_handle)
{      
   if(!is_user_alive(id))
      return FMRES_IGNORED;
 
   new Float: velocity[3];
   pev(id, pev_velocity, velocity);
   new Float: speed = vector_length(velocity);
   if(szybkosc_gracza[id] > speed*1.8)
      set_pev(id, pev_flTimeStepSound, 300);
 
   return FMRES_IGNORED;
}
 
public Odrodzenie(id)
{   
   if(!task_exists(id+ZADANIE_POKAZ_INFORMACJE))
      set_task(0.1, "PokazInformacje", id+ZADANIE_POKAZ_INFORMACJE, _, _, "b");
 
   if(nowa_klasa_gracza[id])
      UstawNowaKlase(id);
 
   if(!klasa_gracza[id])
   {
      WybierzKlase(id);
      return PLUGIN_CONTINUE;
   }
 
   DajBronie(id);
   ZastosujAtrybuty(id);
 
   if(punkty_gracza[id] > 0)
      PrzydzielPunkty(id);
 
   return PLUGIN_CONTINUE;
}
 
public UstawNowaKlase(id)
{
   new ret;
 
   new forward_handle = CreateOneForward(pluginy_klas[klasa_gracza[id]], "cod_class_disabled", FP_CELL, FP_CELL);
   ExecuteForward(forward_handle, ret, id, klasa_gracza[id]);
   DestroyForward(forward_handle);
 
   forward_handle = CreateOneForward(pluginy_klas[nowa_klasa_gracza[id]], "cod_class_enabled", FP_CELL, FP_CELL);
   ExecuteForward(forward_handle, ret, id, nowa_klasa_gracza[id]);
   DestroyForward(forward_handle);
 
 
   if(ret == 4)   
   {
      klasa_gracza[id] = 0;
      return PLUGIN_CONTINUE;
   }
 
   ExecuteForward(klasa_zmieniona, ret, id, klasa_gracza[id]);
 
   if(ret == 4)   
   {
      klasa_gracza[id] = 0;
      return PLUGIN_CONTINUE;
   }
 
   klasa_gracza[id] = nowa_klasa_gracza[id];
   nowa_klasa_gracza[id] = 0;
   UstawPerk(id, perk_gracza[0][id], wartosc_perku_gracza[0][id], 0, 0);
   if(get_user_flags(id) & ADMIN_LEVEL_H){
      UstawPerk(id, perk_gracza[1][id], wartosc_perku_gracza[1][id], 0, 1);
   }
   WczytajDane(id, klasa_gracza[id]);
   return PLUGIN_CONTINUE;
}
 
public DajBronie(id)
{
   for(new i=1; i < 32; i++)
   {
      if((1<<i) & (bronie_klasy[klasa_gracza[id]] | bonusowe_bronie_gracza[id]))
      {
         new weaponname[22];
         get_weaponname(i, weaponname, 21);
         fm_give_item(id, weaponname);
      }
   }
 
   if(gracz_ma_tarcze[id])
      fm_give_item(id, "weapon_shield");
 
   if(gracz_ma_noktowizor[id])
      cs_set_user_nvg(id, 1);
 
   new weapons[32];
   new weaponsnum;
   get_user_weapons(id, weapons, weaponsnum);
   for(new i=0; i<weaponsnum; i++)
      if(is_user_alive(id))
      if(maxAmmo[weapons[i]] > 0)
      cs_set_user_bpammo(id, weapons[i], maxAmmo[weapons[i]]);
}
 
public ZastosujAtrybuty(id)
{
   redukcja_obrazen_gracza[id] = 0.1*(1.0-floatpower(1.1, -0.112311341*PobierzWytrzymalosc(id, 1, 1, 1)));
 
   maksymalne_zdrowie_gracza[id] = 100.0+(PobierzZdrowie(id, 1, 1, 1)*1.6);
 
   szybkosc_gracza[id] = STANDARDOWA_SZYBKOSC+PobierzKondycje(id, 1, 1, 1)*0.3;
 
   set_pev(id, pev_health, maksymalne_zdrowie_gracza[id]);
   wartosc_grawitacji_gracza[id] = float(PobierzGrawitacje(id, 1, 1, 1))/800
   floatclamp(wartosc_grawitacji_gracza[id], 0.0, 0.2) // *TUTAJ MO ESZ ZMIENI?MINIMALNŃ WARTOS?GRAWITACJI JAKŃ MO E MIE?GRACZ. BY TO ZROBI?ZMIEp1. LICZB? PODAJ JŃ W TAKI SPOS?: NP. 0.6 * //
   set_user_gravity(id, get_user_gravity(id)-wartosc_grawitacji_gracza[id]);
}
 
public PoczatekRundy()   
{
   freezetime = false;
   for(new id=0;id<=32;id++)
   {
      if(!is_user_alive(id))
         continue;
 
      Display_Fade(id, 1<<9, 1<<9, 1<<12, 0, 255, 70, 100);
 
      set_task(0.1, "UstawSzybkosc", id+ZADANIE_USTAW_SZYBKOSC);
 
      switch(get_user_team(id))
      {
         case 1: client_cmd(id, "spk QTM_CodMod/start2");
            case 2: client_cmd(id, "spk QTM_CodMod/start");
         }
   }
}
 
public NowaRunda()
   freezetime = true;
 
public Obrazenia(this, idinflictor, idattacker, Float:damage, damagebits)
{
   if(!is_user_alive(idattacker))
      return HAM_IGNORED;
 
   if(get_user_team(this) == get_user_team(idattacker))
      return HAM_IGNORED;
 
   if(get_user_health(this) <= 1)
      return HAM_IGNORED;
 
   SetHamParamFloat(4, damage*(1.0-redukcja_obrazen_gracza[this]));
 
   return HAM_IGNORED;
}
 
public ObrazeniaPost(id, idinflictor, attacker, Float:damage, damagebits)
{
   if(!is_user_connected(attacker) || !klasa_gracza[attacker])
      return HAM_IGNORED;
 
   if(get_user_team(id) != get_user_team(attacker))
   {
      new doswiadczenie_za_obrazenia = get_pcvar_num(cvar_doswiadczenie_za_obrazenia);
      while(damage>20)
      {
         damage -= 20;
         doswiadczenie_gracza[attacker] += doswiadczenie_za_obrazenia;
      }
   }
   SprawdzPoziom(attacker);
   return HAM_IGNORED;
}
 
public SmiercGraczaPost(id, attacker, shouldgib)
{   
   if(!is_user_connected(attacker))
      return HAM_IGNORED;
 
   if(get_user_team(id) != get_user_team(attacker) && klasa_gracza[attacker])
   {
      new doswiadczenie_za_zabojstwo = get_pcvar_num(cvar_doswiadczenie_za_zabojstwo);
      new nowe_doswiadczenie = get_pcvar_num(cvar_doswiadczenie_za_zabojstwo);
 
      if(poziom_gracza[id] > poziom_gracza[attacker])
         nowe_doswiadczenie += (poziom_gracza[id]-poziom_gracza[attacker])*(doswiadczenie_za_zabojstwo/10);
 
      if(!perk_gracza[0][attacker])
         UstawPerk(attacker, -1, -1, 1, 0);
      else if(!perk_gracza[1][attacker] && (get_user_flags(attacker) & ADMIN_LEVEL_H))
         UstawPerk(attacker, -1, -1, 1, 1);
      doswiadczenie_gracza[attacker] += nowe_doswiadczenie;
   }
 
   SprawdzPoziom(attacker);
 
   return HAM_IGNORED;
}
 
public client_authorized(id)
{
   UsunUmiejetnosci(id);
 
   get_user_name(id, nazwa_gracza[id], 63);
 
   UsunZadania(id);
 
   set_task(10.0, "PokazReklame", id+ZADANIE_POKAZ_REKLAME);
}
 
public client_disconnect(id)
{
   ZapiszDane(id);
   UsunUmiejetnosci(id);
   UsunZadania(id);
}
 
public UsunUmiejetnosci(id)
{
   nowa_klasa_gracza[id] = 0;
   UstawNowaKlase(id);
   klasa_gracza[id] = 0;
   poziom_gracza[id] = 0;
   doswiadczenie_gracza[id] = 0;
   punkty_gracza[id] = 0;
   zdrowie_gracza[id] = 0;
   inteligencja_gracza[id] = 0;
   wytrzymalosc_gracza[id] = 0;
   grawitacja_gracza[id] = 0;
   kondycja_gracza[id] = 0;
   grawitacja_gracza[id] = 0;
   bonusowe_zdrowie_gracza[id] = 0;
   bonusowa_wytrzymalosc_gracza[id] = 0;
   bonusowa_inteligencja_gracza[id] = 0;
   bonusowa_kondycja_gracza[id] = 0;
   bonusowa_grawitacja_gracza[id] = 0;
   maksymalne_zdrowie_gracza[id] = 0.0;
   szybkosc_gracza[id] = 0.0;
   UstawPerk(id, 0, 0, 0, 0);
   UstawPerk(id, 0, 0, 0, 1);
}
 
public UsunZadania(id)
{
   remove_task(id+ZADANIE_POKAZ_INFORMACJE);
   remove_task(id+ZADANIE_POKAZ_REKLAME);   
   remove_task(id+ZADANIE_USTAW_SZYBKOSC);
}
 
public WygranaTerro()
   WygranaRunda("TERRORIST");
 
public WygranaCT()
   WygranaRunda("CT");
 
public WygranaRunda(const Team[])
{
   new Players[32], playerCount, id;
   get_players(Players, playerCount, "aeh", Team);
   new doswiadczenie_za_wygrana = get_pcvar_num(cvar_doswiadczenie_za_wygrana);
 
   if(get_playersnum() < 3)
      return;
 
   for (new i=0; i<playerCount; i++) 
   {
      id = Players[i];
      if(!klasa_gracza[id])
         continue;
 
      doswiadczenie_gracza[id] += doswiadczenie_za_wygrana;
      client_print(id, print_chat, "[COD:MW3] Dostales %i doswiadczenia za wygrana runde.", doswiadczenie_za_wygrana);
      SprawdzPoziom(id);
   }
}
 
public KomendaOpisPerku(id)
   OpisPerku(id, perk_gracza[0][id], wartosc_perku_gracza[0][id]);
 
public KomendaOpisPerku2(id)
   OpisPerku(id, perk_gracza[1][id], wartosc_perku_gracza[1][id]);   
 
public OpisPerku(id, perk, wartosc)
{
	new opis_perku[MAX_WIELKOSC_OPISU];
	new losowa_wartosc[15];
	if(wartosc > -1)
		num_to_str(wartosc, losowa_wartosc, 14);
	else
		format(losowa_wartosc, charsmax(losowa_wartosc), "%i-%i", min_wartosci_perkow[perk], max_wartosci_perkow[perk]);
 
	format(opis_perku, charsmax(opis_perku), opisy_perkow[perk]);
	replace_all(opis_perku, charsmax(opis_perku), "LW", losowa_wartosc);
 
	new opis[416+MAX_WIELKOSC_OPISU];
	format(opis, charsmax(opis), "d[ rCall of Duty w4001lvlid]^n^nr|| wNazwa yPerku r||^nr|| w%sr ||^nr|| wOpis yperkur ||^nr|| w%sr ||^n^nr|| wPerky#1 wuzywasz na x r||^nr|| wPerky#2 wuzywasz na c r||", nazwy_perkow[perk], opis_perku);
	show_menu(id, 1023, opis);
 
	return PLUGIN_CONTINUE;
}
 
public OpisPerku2(id, perk, wartosc)
{
	new opis_perku[MAX_WIELKOSC_OPISU];
	new losowa_wartosc[15];
	if(wartosc > -1)
		num_to_str(wartosc, losowa_wartosc, 14);
	else
		format(losowa_wartosc, charsmax(losowa_wartosc), "%i-%i", min_wartosci_perkow[perk], max_wartosci_perkow[perk]);
 
	format(opis_perku, charsmax(opis_perku), opisy_perkow[perk]);
	replace_all(opis_perku, charsmax(opis_perku), "LW", losowa_wartosc);
 
	client_print(id, print_chat, "Perk: %s.", nazwy_perkow[perk]);
	client_print(id, print_chat, "Opis: %s.", opis_perku);
}
 
public OpisPerkow(id)
{
	new menu = menu_create("Wybierz Perk:", "OpisPerkow_Handle");
	for(new i=1; i <= ilosc_perkow; i++)
		menu_additem(menu, nazwy_perkow[i]);
	menu_setprop(menu, MPROP_EXITNAME, "Wyjdz");
	menu_setprop(menu, MPROP_BACKNAME, "Poprzednia strona");
	menu_setprop(menu, MPROP_NEXTNAME, "Nastepna strona");
	menu_display(id, menu);
	client_cmd(id, "spk QTM_CodMod/select");
}
 
public OpisPerkow_Handle(id, menu, item)
{
	if(item++ == MENU_EXIT)
	{
		menu_destroy(menu);
		return PLUGIN_CONTINUE;
	}
	OpisPerku2(id, item, -1);
	OpisPerkow(id);
	return PLUGIN_CONTINUE;
}
 
public OpisKlasy(id)
{
   new menu = menu_create("Wybierz klase:", "OpisKlasy_Handle");
   for(new i=1; i <= ilosc_klas; i++)
      menu_additem(menu, nazwy_klas[i]);
   menu_setprop(menu, MPROP_EXITNAME, "Wyjdz");
   menu_setprop(menu, MPROP_BACKNAME, "Poprzednia strona");
   menu_setprop(menu, MPROP_NEXTNAME, "Nastepna strona");
   menu_display(id, menu);
 
   client_cmd(id, "spk QTM_CodMod/select");
}
 
public OpisKlasy_Handle(id, menu, item)
{
   client_cmd(id, "spk QTM_CodMod/select");
 
   if(item++ == MENU_EXIT)
   {
      menu_destroy(menu);
      return PLUGIN_CONTINUE;
   }
 
   new bronie[320];
   for(new i=1, n=1; i <= 32; i++)
   {
      if((1<<i) & bronie_klasy[item])
      {
         new weaponname[22];
         get_weaponname(i, weaponname, 21);
         replace_all(weaponname, 21, "weapon_", " ");
         if(n > 1)   
            add(bronie, charsmax(bronie), ",");
         add(bronie, charsmax(bronie), weaponname);
         n++;
      }
   }
 
   new opis[416+MAX_WIELKOSC_OPISU];
   format(opis, charsmax(opis), "yKlasa: w%s^nyInteligencja: w%i^nyZdrowie: w%i^nyWytrzymalosc: w%i^nyKondycja: w%i^nyGrawitacja: w%i^nyBronie:w%s^nyDodatkowy opis: w%s^n%s", nazwy_klas[item], inteligencja_klas[item], zdrowie_klas[item], wytrzymalosc_klas[item], kondycja_klas[item], grawitacja_klas[item], bronie, opisy_klas[item], opisy_klas[item][79]);
   if(awansuje_z[item])
   format(opis, charsmax(opis), "%s^nyAwansuje z: w%s (Wymagany poziom: %i)", opis, nazwy_klas[awansuje_z[item]], awanse[ZnajdzAwans(awansuje_z[item], item)][2]);
   if(awansuje_do[item])
   format(opis, charsmax(opis), "%s^nyAwansuje do: w%s (Wymagany poziom: %i)", opis, nazwy_klas[awansuje_do[item]], awanse[ZnajdzAwans(item, awansuje_do[item])][2]);
   show_menu(id, 1023, opis);
 
   return PLUGIN_CONTINUE;
}
 
public bool:is_in_previous(frakcja[],from){
   for(new i = from - 1;i>=1;i--){
      if(equali(frakcja_klas[i],frakcja)){
         return true;
      }
   }
   return false;
}
 
public WybierzKlase(id)
{
   new menu = menu_create("Wybierz klase:", "WybierzKlase_Frakcje");
   for(new i=1; i <= ilosc_klas; i++)
   {
      if(!equal(frakcja_klas[i],"") && !is_in_previous(frakcja_klas[i],i)){
         menu_additem(menu,frakcja_klas[i],frakcja_klas[i])
      }
   }
 
   menu_setprop(menu, MPROP_EXITNAME, "Wyjdz");
   menu_setprop(menu, MPROP_BACKNAME, "Poprzednia strona");
   menu_setprop(menu, MPROP_NEXTNAME, "Nastepna strona");
   menu_display(id, menu);
}
 
public WybierzKlase_Frakcje(id, menu, item)
{
   if(item == MENU_EXIT){
      menu_destroy(menu);
      return PLUGIN_CONTINUE;
   }
 
   new data[65], iName[64] 
   new acces, callback 
   menu_item_getinfo(menu, item, acces, data,64, iName, 63, callback) 
 
   new menu2 = menu_create("Wybierz klase:", "WybierzKlase_Handle");
 
   new klasa[50], szTmp[5];
   for(new i=1; i <= ilosc_klas; i++)
   {
      if(equali(data,frakcja_klas[i]))
      {
         if(awansuje_z[i])
         {
            new bool:moze = false;
            WczytajDane(id, awansuje_z[i]);
            if(poziom_gracza[id] >= awanse[ZnajdzAwans(awansuje_z[i], i)][2])
               moze = true;
 
            WczytajDane(id, i);
            if(moze) formatex(klasa, charsmax(klasa), "%s yPoziom: %i", nazwy_klas[i], poziom_gracza[id]);
            else formatex(klasa, charsmax(klasa), "r%s yPoziom: %i", nazwy_klas[i], poziom_gracza[id]);
         }
         else
         {
            WczytajDane(id, i);
            formatex(klasa, charsmax(klasa), "%s yPoziom: %i", nazwy_klas[i], poziom_gracza[id]);
         }
         num_to_str(i, szTmp, charsmax(szTmp));
         menu_additem(menu2, klasa, szTmp);
      }
   }
 
   WczytajDane(id, klasa_gracza[id]);
 
   menu_setprop(menu2, MPROP_EXITNAME, "Wyjdz");
   menu_setprop(menu2, MPROP_BACKNAME, "Poprzednia strona");
   menu_setprop(menu2, MPROP_NEXTNAME, "Nastepna strona");
   menu_display(id, menu2);
 
   client_cmd(id, "spk QTM_CodMod/select");
 
   menu_destroy(menu);
   return PLUGIN_CONTINUE;
}
 
public WybierzKlase_Handle(id, menu, item)
{
   client_cmd(id, "spk QTM_CodMod/select");
 
   if(item == MENU_EXIT)
   {
      menu_destroy(menu);
      return PLUGIN_CONTINUE;
   }       
 
   new data[65], iName[64] 
   new acces, callback 
   menu_item_getinfo(menu, item, acces, data,64, iName, 63, callback) 
 
   item = str_to_num(data);
 
   if(awansuje_z[item])
   {
      WczytajDane(id, awansuje_z[item]);
      new bool:moze, a = ZnajdzAwans(awansuje_z[item], item)
      if(poziom_gracza[id] >= awanse[a][2])
         moze = true;
      WczytajDane(id, klasa_gracza[id]);
      if(!moze)
      {
         client_print(id, print_chat, "[COD:MW3] Aby uzywac tej klasy musisz zdobyc %i poziom na klasie %s!", awanse[a][2], nazwy_klas[awansuje_z[item]]);
         return PLUGIN_CONTINUE;
      }
   }
 
   if(item == klasa_gracza[id] && !nowa_klasa_gracza[id])
      return PLUGIN_CONTINUE;
 
   nowa_klasa_gracza[id] = item;
 
   if(klasa_gracza[id])
      client_print(id, print_chat, "[COD:MW3] Klasa zostanie zmieniona w nastepnej rundzie.");
   else
   {
      UstawNowaKlase(id);
      DajBronie(id);
      ZastosujAtrybuty(id);
   }
 
   return PLUGIN_CONTINUE;
}
 
public PrzydzielPunkty(id)
{
   new inteligencja[65];
   new zdrowie[60];
   new wytrzymalosc[60];
   new kondycja[60];
   new grawitacja[60];
   new tytul[25];
   new allkondycja[60];
   new allinteligencja[60];
   new allwytrzymalosc[60];
   new allzdrowie[60];
   new allgrawitacja[60];
   new kondycjaa[60];
   new wytrzymalosca[60];
   new zdrowiea[60];
   new inteligencjaa[60];
   new grawitacjaa[60];
   format(inteligencja, charsmax(inteligencja), "Inteligencja: r%i y/r 1300y (Zwieksza sile perkow i umiejetnosci klasy)", PobierzInteligencje(id, 1, 1, 1));
   format(zdrowie, charsmax(zdrowie), "Zdrowie: r%i y/r 3200y (Zwieksza zdrowie)", PobierzZdrowie(id, 1, 1, 1));
   format(wytrzymalosc, charsmax(wytrzymalosc), "Wytrzymalosc: r%i y/r 1100y (Zmniejsza obrazenia)", PobierzWytrzymalosc(id, 1, 1, 1));
   format(kondycja, charsmax(kondycja), "Kondycja: r%i y/r 2000y (Zwieksza tempo chodu)", PobierzKondycje(id, 1, 1, 1));
   format(grawitacja, charsmax(grawitacja), "Grawitacja: r%i y/r 400y (Zmniejsza grawitacje)", PobierzGrawitacje(id, 1, 1, 1));
   format(tytul, charsmax(tytul), "Przydziel Punkty(%i):", punkty_gracza[id]);
   format(allinteligencja, charsmax(allinteligencja), "Dodaj wszystko w inteligencje");
   format(allkondycja, charsmax(allkondycja), "Dodaj wszystko w kondycje");
   format(allzdrowie, charsmax(allzdrowie), "Dodaj wszystko w zdrowie");
   format(allwytrzymalosc, charsmax(allwytrzymalosc), "Dodaj wszystko w wytrzymalosc");
   format(allgrawitacja, charsmax(allgrawitacja), "Dodaj wszystko w grawitacje");
   format(kondycjaa, charsmax(kondycjaa), "Dodaj 10 punktow w kondycje");
   format(zdrowiea, charsmax(zdrowiea), "Dodaj 10 punktow w zdrowie");
   format(inteligencjaa, charsmax(inteligencjaa), "Dodaj 10 punktow w inteligencje");
   format(wytrzymalosca, charsmax(wytrzymalosca), "Dodaj 10 punktow w wytrzymalosc");
   format(grawitacjaa, charsmax(grawitacjaa), "Dodaj 10 punktow w grawitacje");
   new menu = menu_create(tytul, "PrzydzielPunkty_Handler");
   menu_additem(menu, inteligencja);
   menu_additem(menu, zdrowie);
   menu_additem(menu, wytrzymalosc);
   menu_additem(menu, kondycja);
   menu_additem(menu, grawitacja);
   menu_additem(menu, inteligencjaa);
   menu_additem(menu, zdrowiea);
   menu_additem(menu, wytrzymalosca);
   menu_additem(menu, kondycjaa);
   menu_additem(menu, grawitacjaa);
   menu_additem(menu, allinteligencja);
   menu_additem(menu, allzdrowie);
   menu_additem(menu, allwytrzymalosc);
   menu_additem(menu, allkondycja);
   menu_additem(menu, allgrawitacja);
   menu_setprop(menu, MPROP_EXITNAME, "Wyjdz");
   menu_setprop(menu, MPROP_BACKNAME, "Poprzednia strona");
   menu_setprop(menu, MPROP_NEXTNAME, "Nastepna strona");
   menu_display(id, menu);
}
 
public PrzydzielPunkty_Handler(id, menu, item)
{
   client_cmd(id, "spk QTM_CodMod/select");
 
   if(item == MENU_EXIT)
   {
      menu_destroy(menu);
      return PLUGIN_CONTINUE;
   }
 
   if(punkty_gracza[id] < 1)
      return PLUGIN_CONTINUE;
 
   new limit_int, limit_zdr, limit_kon, limit_wyt, limit_gra;
   limit_int = 1300;
   limit_zdr = 3200;
   limit_kon = 2000;
   limit_wyt = 1100;
   limit_gra = 400;
 
   switch(item) 
   { 
      case 0: 
      {   
         if(inteligencja_gracza[id] < limit_int)
         {
            inteligencja_gracza[id]++;
            punkty_gracza[id]--;
         }
         else 
            client_print(id, print_chat, "[COD:MW3] Maksymalny poziom inteligencji osiagniety");
 
 
      }
      case 1: 
      {   
         if(zdrowie_gracza[id] < limit_zdr)
         {
            zdrowie_gracza[id]++;
            punkty_gracza[id]--;
         }
         else 
            client_print(id, print_chat, "[COD:MW3] Maksymalny poziom zdrowia osiagniety");
      }
      case 2: 
      {   
         if(wytrzymalosc_gracza[id] < limit_wyt)
         {
            wytrzymalosc_gracza[id]++;
            punkty_gracza[id]--;
         }
         else 
            client_print(id, print_chat, "[COD:MW3] Maksymalny poziom wytrzymalosci osiagniety");
 
      }
      case 3: 
      {   
         if(kondycja_gracza[id] < limit_kon)
         {
            kondycja_gracza[id]++;
            punkty_gracza[id]--;
         }
         else
            client_print(id, print_chat, "[COD:MW3] Maksymalny poziom kondycji osiagniety");
      }
      case 4: 
      {   
         if(grawitacja_gracza[id] < limit_gra)
         {
            grawitacja_gracza[id]++;
            punkty_gracza[id]--;
         }
         else
            client_print(id, print_chat, "[COD:MW3] Maksymalny poziom grawitacji osiagniety");
      }
      case 5: 
      {   
         if(inteligencja_gracza[id] < limit_int)
         {
            if(punkty_gracza[id] < 10)
            {
               client_print(id, print_chat, "[COD:MW3] Masz za malo punktow do rozdania");
            }
            else
            {
               if(inteligencja_gracza[id] + 10 <= limit_int)
               {
                  inteligencja_gracza[id] += 10;
                  punkty_gracza[id] -= 10;
               }
               else
               {
                  new punktydododania;
                  punktydododania = limit_int - inteligencja_gracza[id];
                  inteligencja_gracza[id] += punktydododania;
                  punkty_gracza[id] -= punktydododania;
               }
            }
         }
         else 
            client_print(id, print_chat, "[COD:MW3] Maksymalny poziom inteligencji osiagniety");
 
 
      }
      case 6: 
      {   
         if(zdrowie_gracza[id] < limit_zdr)
         {
            if(punkty_gracza[id] < 10)
            {
               client_print(id, print_chat, "[COD:MW3] Masz za malo punktow do rozdania");
            }
            else
            {
               if(zdrowie_gracza[id] + 10 <= limit_zdr)
               {
                  zdrowie_gracza[id] += 10;
                  punkty_gracza[id] -= 10;
               }
               else
               {
                  new punktydododania;
                  punktydododania = limit_zdr - zdrowie_gracza[id];
                  zdrowie_gracza[id] += punktydododania;
                  punkty_gracza[id] -= punktydododania;
               }
            }
         }
         else 
            client_print(id, print_chat, "[COD:MW3] Maksymalny poziom zdrowia osiagniety");
      }
      case 7: 
      {   
         if(wytrzymalosc_gracza[id] < limit_wyt)
         {
            if(punkty_gracza[id] < 10)
            {
               client_print(id, print_chat, "[COD:MW3] Masz za malo punktow do rozdania");
            }
            else
            {
               if(wytrzymalosc_gracza[id] + 10 <= limit_wyt)
               {
                  wytrzymalosc_gracza[id] += 10;
                  punkty_gracza[id] -= 10;
               }
               else
               {
                  new punktydododania;
                  punktydododania = limit_wyt - wytrzymalosc_gracza[id];
                  wytrzymalosc_gracza[id] += punktydododania;
                  punkty_gracza[id] -= punktydododania;
               }
            }
         }
         else 
            client_print(id, print_chat, "[COD:MW3 Maksymalny poziom wytrzymalosci osiagniety");
 
      }
      case 8: 
      {   
         if(kondycja_gracza[id] < limit_kon)
         {
            if(punkty_gracza[id] < 10)
            {
               client_print(id, print_chat, "[COD:MW3] Masz za malo punktow do rozdania");
            }
            else
            {
               if(kondycja_gracza[id] + 10 <= limit_kon)
               {
                  kondycja_gracza[id] += 10;
                  punkty_gracza[id] -= 10;
               }
               else
               {
                  new punktydododania;
                  punktydododania = limit_kon - kondycja_gracza[id];
                  kondycja_gracza[id] += punktydododania;
                  punkty_gracza[id] -= punktydododania;
               }
            }
         }
         else
            client_print(id, print_chat, "[COD:MW3] Maksymalny poziom kondycji osiagniety");
      }
      case 9: 
      {   
         if(grawitacja_gracza[id] < limit_gra)
         {
            if(punkty_gracza[id] < 10)
            {
               client_print(id, print_chat, "[COD:MW3] Masz za malo punktow do rozdania");
            }
            else
            {
               if(grawitacja_gracza[id] + 10 <= limit_kon)
               {
                  grawitacja_gracza[id] += 10;
                  punkty_gracza[id] -= 10;
               }
               else
               {
                  new punktydododania;
                  punktydododania = limit_gra - grawitacja_gracza[id];
                  grawitacja_gracza[id] += punktydododania;
                  punkty_gracza[id] -= punktydododania;
               }
            }
         }
         else
            client_print(id, print_chat, "[COD:MW3] Maksymalny poziom grawitacji osiagniety");
      }
      case 10: 
      {   
         if(inteligencja_gracza[id] < limit_int)
         {
            if(punkty_gracza[id] > limit_int - inteligencja_gracza[id])
            {
               punkty_gracza[id] = punkty_gracza[id] + inteligencja_gracza[id] - limit_int;
               inteligencja_gracza[id] = limit_int;
            }
            else
            {
               inteligencja_gracza[id] = inteligencja_gracza[id] + punkty_gracza[id];
               punkty_gracza[id] = 0;
            }
         }
         else 
            client_print(id, print_chat, "[COD:MW3] Maksymalny poziom inteligencji osiagniety");
 
 
      }
      case 11: 
      {   
         if(zdrowie_gracza[id] < limit_zdr)
         {
            if(punkty_gracza[id] > limit_zdr - zdrowie_gracza[id])
            {
               punkty_gracza[id] = punkty_gracza[id] + zdrowie_gracza[id] - limit_zdr;
               zdrowie_gracza[id] = limit_zdr;
            }
            else
            {
               zdrowie_gracza[id] = zdrowie_gracza[id] + punkty_gracza[id];
               punkty_gracza[id] = 0;
            }
         }
         else 
            client_print(id, print_chat, "[COD:MW3] Maksymalny poziom zdrowia osiagniety");
      }
      case 12: 
      {   
         if(wytrzymalosc_gracza[id] < limit_wyt)
         {
            if(punkty_gracza[id] > limit_wyt - wytrzymalosc_gracza[id])
            {
               punkty_gracza[id] = punkty_gracza[id] + wytrzymalosc_gracza[id] - limit_wyt;
               wytrzymalosc_gracza[id] = limit_wyt;
            }
            else
            {
               wytrzymalosc_gracza[id] = wytrzymalosc_gracza[id] + punkty_gracza[id];
               punkty_gracza[id] = 0;
            }
         }
         else 
            client_print(id, print_chat, "[COD:MW3] Maksymalny poziom wytrzymalosci osiagniety");
 
      }
      case 13: 
      {   
         if(kondycja_gracza[id] < limit_kon)
         {
            if(punkty_gracza[id] > limit_kon - kondycja_gracza[id])
            {
               punkty_gracza[id] = punkty_gracza[id] + kondycja_gracza[id] - limit_kon;
               kondycja_gracza[id] = limit_kon;
            }
            else
            {
               kondycja_gracza[id] = kondycja_gracza[id] + punkty_gracza[id];
               punkty_gracza[id] = 0;
            }
         }
         else
            client_print(id, print_chat, "[COD:MW3] Maksymalny poziom kondycji osiagniety");
      }
      case 14:    
         if(grawitacja_gracza[id] < limit_gra)
      {
         if(punkty_gracza[id] > limit_gra - grawitacja_gracza[id])
         {
            punkty_gracza[id] = punkty_gracza[id] + grawitacja_gracza[id] - limit_gra;
            grawitacja_gracza[id] = limit_gra;
         }
         else
         {
            grawitacja_gracza[id] = grawitacja_gracza[id] + punkty_gracza[id];
            punkty_gracza[id] = 0;
         }
      }
         else
         client_print(id, print_chat, "[COD:MW3] Maksymalny poziom grawitacji osiagniety");
   }
 
   if(punkty_gracza[id] > 0)
      PrzydzielPunkty(id);
 
   return PLUGIN_CONTINUE;
}
 
public KomendaResetujPunkty(id)
{   
   client_print(id, print_chat, "[COD:MW3] Umiejetnosci zostana zresetowane.");
   client_cmd(id, "spk QTM_CodMod/select");
 
   ResetujPunkty(id);
}
 
public ResetujPunkty(id)
{
   punkty_gracza[id] = (poziom_gracza[id]-1)*2;
   inteligencja_gracza[id] = 0;
   zdrowie_gracza[id] = 0;
   kondycja_gracza[id] = 0;
   wytrzymalosc_gracza[id] = 0;
 
   if(punkty_gracza[id])
      PrzydzielPunkty(id);
}
 
public CurWeapon(id)
{
   if(!is_user_connected(id))
      return;
 
   new team = get_user_team(id);
 
   if(team > 2)
      return;
 
   new bron = read_data(2);
 
   new bronie = (bronie_klasy[klasa_gracza[id]] | bonusowe_bronie_gracza[id] | bronie_druzyny[team] | bronie_dozwolone);
 
   if(!(1<<bron & bronie))
   {
      new weaponname[22];
 
      get_weaponname(bron, weaponname, 21);
      ham_strip_weapon(id, weaponname);
   }
 
   if(cs_get_user_shield(id) && !gracz_ma_tarcze[id])
      engclient_cmd(id, "drop", "weapon_shield");   
 
   UstawSzybkosc(id);
}
 
public EmitSound(id, iChannel, szSound[], Float:fVol, Float:fAttn, iFlags, iPitch ) 
{
   if(!is_user_alive(id))
      return FMRES_IGNORED;
 
   if(equal(szSound, "common/wpn_denyselect.wav"))
   {
      new forward_handle = CreateOneForward(pluginy_klas[klasa_gracza[id]], "cod_class_skill_used", FP_CELL);
      ExecuteForward(forward_handle, id, id);
      DestroyForward(forward_handle);
      return FMRES_SUPERCEDE;
   }
 
   if(equal(szSound, "items/ammopickup2.wav"))
   {
      cs_set_user_armor(id, 0, CS_ARMOR_NONE);
      return FMRES_SUPERCEDE;
   }
 
   if(equal(szSound, "items/equip_nvg.wav") && !gracz_ma_noktowizor[id])
   {
      cs_set_user_nvg(id, 0);
      return FMRES_SUPERCEDE;
   }
 
   return FMRES_IGNORED;
}
 
 
public UzyjPerku(id)
   return UzyjPerki(id, 0);
 
public UzyjPerku2(id)
   return UzyjPerki(id, 1);
 
public UzyjPerki(id, lp)
{
   if(!is_user_alive(id))
      return PLUGIN_HANDLED;
 
   new forward_handle = forward_handle = CreateOneForward(pluginy_perkow[perk_gracza[lp][id]], "cod_perk_used", FP_CELL);
   ExecuteForward(forward_handle, id, id);
   DestroyForward(forward_handle);
   return PLUGIN_HANDLED;
}
 
public ZapiszDane(id)
{
   if(!klasa_gracza[id])
      return PLUGIN_CONTINUE;
 
   new vaultkey[128],vaultdata[256], identyfikator[64];
   format(vaultdata, charsmax(vaultdata),"#%i#%i#%i#%i#%i#%i#%i", doswiadczenie_gracza[id], poziom_gracza[id], inteligencja_gracza[id], zdrowie_gracza[id], wytrzymalosc_gracza[id], kondycja_gracza[id], grawitacja_gracza[id]);
 
   new typ_zapisu = get_pcvar_num(cvar_typ_zapisu);
 
   switch(typ_zapisu)
   {
      case 1: copy(identyfikator, charsmax(identyfikator), nazwa_gracza[id]);
         case 2: get_user_authid(id, identyfikator, charsmax(identyfikator));
         case 3: get_user_ip(id, identyfikator, charsmax(identyfikator));
      }
 
   format(vaultkey, charsmax(vaultkey),"%s-%s-%i-cod", identyfikator, nazwy_klas[klasa_gracza[id]], typ_zapisu);
   nvault_set(vault,vaultkey,vaultdata);
 
   return PLUGIN_CONTINUE;
}
 
public WczytajDane(id, klasa)
{
   new vaultkey[128],vaultdata[256], identyfikator[64];
 
   new typ_zapisu = get_pcvar_num(cvar_typ_zapisu);
 
   switch(typ_zapisu)
   {
      case 1: copy(identyfikator, charsmax(identyfikator), nazwa_gracza[id]);
         case 2: get_user_authid(id, identyfikator, charsmax(identyfikator));
         case 3: get_user_ip(id, identyfikator, charsmax(identyfikator));
      }
 
   format(vaultkey, charsmax(vaultkey),"%s-%s-%i-cod", identyfikator, nazwy_klas[klasa], typ_zapisu);
 
 
   if(!nvault_get(vault,vaultkey,vaultdata,255)) // Jezeli nie ma danych gracza sprawdza stary zapis. 
   {
      format(vaultkey, charsmax(vaultkey), "%s-%i-cod", nazwa_gracza[id], klasa);
      nvault_get(vault,vaultkey,vaultdata,255);
   }
 
   replace_all(vaultdata, 255, "#", " ");
 
   new danegracza[7][32];
 
   parse(vaultdata, danegracza[0], 31, danegracza[1], 31, danegracza[2], 31, danegracza[3], 31, danegracza[4], 31, danegracza[5], 31, danegracza[6], 31);
 
   doswiadczenie_gracza[id] = str_to_num(danegracza[0]);
   poziom_gracza[id] = str_to_num(danegracza[1])>0?str_to_num(danegracza[1]):1;
   inteligencja_gracza[id] = str_to_num(danegracza[2]);
   zdrowie_gracza[id] = str_to_num(danegracza[3]);
   wytrzymalosc_gracza[id] = str_to_num(danegracza[4]);
   kondycja_gracza[id] = str_to_num(danegracza[5]);
   grawitacja_gracza[id] = str_to_num(danegracza[6]);
   punkty_gracza[id] = (poziom_gracza[id]-1)*2-inteligencja_gracza[id]-zdrowie_gracza[id]-wytrzymalosc_gracza[id]-kondycja_gracza[id]-grawitacja_gracza[id];
 
   return PLUGIN_CONTINUE;
} 
 
 
public WyrzucPerk(id)
   DropPerka(id, 0)
 
public WyrzucPerk2(id)
   DropPerka(id, 1)
 
public DropPerka(id, lp)
{
   if(perk_gracza[lp][id])
   {
      client_print(id, print_chat, "[COD:MW3] Wyrzuciles %s.", nazwy_perkow[perk_gracza[lp][id]]);
      UstawPerk(id, 0, 0, 0, lp);
   }
   else
      client_print(id, print_chat, "[COD:MW3] Nie masz zadnego perku.");
}
 
public SprawdzPoziom(id)
{   
   if(!is_user_connected(id))
      return;
 
   new limit_poziomu = get_pcvar_num(cvar_limit_poziomu);
 
   new bool:zdobyl_poziom = false, bool:stracil_poziom = false;
 
   while(doswiadczenie_gracza[id] >= PobierzDoswiadczeniePoziomu(poziom_gracza[id]) && poziom_gracza[id] < limit_poziomu)
   {
      poziom_gracza[id]++;
      punkty_gracza[id] = (poziom_gracza[id]-1)*2-inteligencja_gracza[id]-zdrowie_gracza[id]-wytrzymalosc_gracza[id]-kondycja_gracza[id]-grawitacja_gracza[id];
      zdobyl_poziom = true;
   }
 
   while(doswiadczenie_gracza[id] < PobierzDoswiadczeniePoziomu(poziom_gracza[id]-1))
   {
      poziom_gracza[id]--;
      stracil_poziom = true;
   }
 
   if(poziom_gracza[id] > limit_poziomu)
   {
      poziom_gracza[id] = limit_poziomu;
      ResetujPunkty(id);
   }
 
   if(stracil_poziom)
   {
      ResetujPunkty(id);
      set_hudmessage(212, 255, 85, 0.31, 0.32, 0, 6.0, 5.0);
      ShowSyncHudMsg(id, SyncHudObj2,"Spadles do %i poziomu!", poziom_gracza[id]);
   }
   else if(zdobyl_poziom)
   {
      punkty_gracza[id] = (poziom_gracza[id]-1)*2-inteligencja_gracza[id]-zdrowie_gracza[id]-wytrzymalosc_gracza[id]-kondycja_gracza[id]-grawitacja_gracza[id];
      set_hudmessage(212, 255, 85, 0.31, 0.32, 0, 6.0, 5.0);
      ShowSyncHudMsg(id, SyncHudObj2,"Awansowales do %i poziomu!", poziom_gracza[id]);
      client_cmd(id, "spk QTM_CodMod/levelup");
   }
 
   ZapiszDane(id);
 
      if(awansuje_do[klasa_gracza[id]])
   {
      if(poziom_gracza[id] >= awanse[ZnajdzAwans(klasa_gracza[id], awansuje_do[klasa_gracza[id]])][2])
      {
         set_hudmessage(212, 255, 85, 0.31, 0.32, 0, 6.0, 5.0);
         ShowSyncHudMsg(id, SyncHudObj2,"Osiagajac poziom %i, awansowales do klasy %s!", poziom_gracza[id], nazwy_klas[awansuje_do[klasa_gracza[id]]]);
         ZapiszDane(id);
      }
   }
}
 
public PokazInformacje(id)
{
   id -= ZADANIE_POKAZ_INFORMACJE;
 
   new bool:pytajvip = bool:(get_user_flags(id) & ADMIN_LEVEL_H);
 
   if(!is_user_connected(id))
   {
      remove_task(id+ZADANIE_POKAZ_INFORMACJE);
      return PLUGIN_CONTINUE;
   }
 
   if(!is_user_alive(id))
   {
      new target = pev(id, pev_iuser2);
      new bool:pytajvipnoalive = bool:(get_user_flags(target) & ADMIN_LEVEL_H);
      new hp = get_user_health(target);
 
      if(!target)
         return PLUGIN_CONTINUE;
 
      new ileMa = doswiadczenie_gracza[target],ilePotrzeba = PobierzDoswiadczeniePoziomu(poziom_gracza[target]),ilePotrzebaBylo = poziom_gracza[target]-1 >= 0 ? PobierzDoswiadczeniePoziomu(poziom_gracza[target]-1) : 0;
      new Float:fProcent = 0.0;
      fProcent = (float((ileMa - ilePotrzebaBylo)) / float((ilePotrzeba - ilePotrzebaBylo))) * 100.0;
      if(!is_user_alive(id))
 
      if(get_user_flags(target) & ADMIN_LEVEL_H)
      {
         set_hudmessage(0,0,139, 0.6, -1.0, 0, 0.0, 0.3, 0.0, 0.0, 2);
         ShowSyncHudMsg(id, SyncHudObj, "*Zapraszamy na forum FairGame-cs.pl*^n[VIP: %s]^n[Klasa : %s]^n[Doswiadczenie : %i / %i %0.1f%%]^n[Poziom : %i]^n[Perk : %s | %s]^n[Monety : %i]^n[Zdrowie : %d]",pytajvipnoalive ? "TAK" : "NIE", nazwy_klas[klasa_gracza[target]], doswiadczenie_gracza[target], PobierzDoswiadczeniePoziomu(poziom_gracza[target]), fProcent, poziom_gracza[target], nazwy_perkow[perk_gracza[0][target]], nazwy_perkow[perk_gracza[1][target]], cod_get_user_coins(target), hp);//
      }
      else
      {
         set_hudmessage(0,0,139, 0.6, -1.0, 0, 0.0, 0.3, 0.0, 0.0, 2);
         ShowSyncHudMsg(id, SyncHudObj, "*Zapraszamy na forum FairGame-cs.pl*^n[VIP: %s]^n[Klasa : %s]^n[Doswiadczenie : %i / %i %0.1f%%]^n[Poziom : %i]^n[Perk : %s | !Tylko dla VIP!]^n[Monety : %i]^n[Zdrowie : %d]",pytajvipnoalive ? "TAK" : "NIE", nazwy_klas[klasa_gracza[target]], doswiadczenie_gracza[target], PobierzDoswiadczeniePoziomu(poziom_gracza[target]), fProcent, poziom_gracza[target], nazwy_perkow[perk_gracza[0][target]], cod_get_user_coins(target), hp);//
 
      }
      return PLUGIN_CONTINUE;
   }
   new ileMa = doswiadczenie_gracza[id],ilePotrzeba = PobierzDoswiadczeniePoziomu(poziom_gracza[id]),ilePotrzebaBylo = poziom_gracza[id]-1 >= 0 ?PobierzDoswiadczeniePoziomu(poziom_gracza[id]-1) : 0
   new Float:fProcent = 0.0;
   fProcent = (float((ileMa - ilePotrzebaBylo)) / float((ilePotrzeba - ilePotrzebaBylo))) * 100.0;
   if(get_user_flags(id) & ADMIN_LEVEL_H)
   {
      set_hudmessage(0, 255, 0, 0.02, 0.23, 0, 0.0, 0.3, 0.0, 0.0);
      ShowSyncHudMsg(id, SyncHudObj, "[Cod:4001lvl | Forum - FairGame-cs.pl]^n[VIP: %s]^n[Klasa : %s]^n[Doswiadczenie : %i / %i %0.1f%%]^n[Poziom : %i]^n[Perk : %s | %s]^n[Monety : %i]^n[Zdrowie : %d]",pytajvip ? "TAK" : "NIE", nazwy_klas[klasa_gracza[id]], doswiadczenie_gracza[id], PobierzDoswiadczeniePoziomu(poziom_gracza[id]), fProcent, poziom_gracza[id], nazwy_perkow[perk_gracza[0][id]], nazwy_perkow[perk_gracza[1][id]], cod_get_user_coins(id), get_user_health(id));
   }
   else
   {
      set_hudmessage(0, 255, 0, 0.02, 0.23, 0, 0.0, 0.3, 0.0, 0.0);
      ShowSyncHudMsg(id, SyncHudObj, "[Cod:4001lvl | Forum - FairGame-cs.pl]^n[VIP: %s]^n[Klasa : %s]^n[Doswiadczenie : %i / %i %0.1f%%]^n[Poziom : %i]^n[Perk : %s | !Tylko dla VIP! ]^n[Monety : %i]^n[Zdrowie : %d]",pytajvip ? "TAK" : "NIE", nazwy_klas[klasa_gracza[id]], doswiadczenie_gracza[id], PobierzDoswiadczeniePoziomu(poziom_gracza[id]),fProcent, poziom_gracza[id], nazwy_perkow[perk_gracza[0][id]], cod_get_user_coins(id), get_user_health(id));
   }
   return PLUGIN_CONTINUE;
}
 
public PokazReklame(id)
{
   id-=ZADANIE_POKAZ_REKLAME;
   client_print(id, print_chat, "[COD:MW3] Witaj w Modyfikacji Call of Duty stworzonej przez QTM_Peyote edit by Qazz");
   client_print(id, print_chat, "[COD:MW3] W celu uzyskania informacji o komendach napisz /pomoc.");
   client_print(id, print_chat, "[COD:MW3] Zapraszamy na FairGame-cs.pl");
 
}
 
public Pomoc(id)
   show_menu(id, 1023, "y/resetw - resetuje statystyki^ny/statystykiw - wyswietla statystyki^ny/klasaw - uruchamia menu wyboru klas^ny/wyrzucw - wyrzuca perk^ny/perkw - pokazuje opis twojego perku^ny/klasyw - pokazuje opisy klas^ny/evow - informacje o klasach evo^ny/awanseinfw - informacje o awansach", -1, "Pomoc");
 
public UstawSzybkosc(id)
{
   id -= id>32? ZADANIE_USTAW_SZYBKOSC: 0;
 
   if(klasa_gracza[id] && !freezetime)
      set_pev(id, pev_maxspeed, szybkosc_gracza[id]);
}
 
public DotykBroni(weapon, id)
{
   if(get_pcvar_num(cvar_blokada_broni) < 1)
      return HAM_IGNORED;
 
   if(!is_user_connected(id))
      return HAM_IGNORED;
 
   new model[23];
   pev(weapon, pev_model, model, 22);
   if (pev(weapon, pev_owner) == id || containi(model, "w_backpack") != -1)
      return HAM_IGNORED;
   return HAM_SUPERCEDE;
}
 
public DotykTarczy(weapon, id)
{
   if(get_pcvar_num(cvar_blokada_broni) < 1)
      return HAM_IGNORED;
 
   if(!is_user_connected(id))
      return HAM_IGNORED;
 
   if(gracz_ma_tarcze[id])
      return HAM_IGNORED;
 
   return HAM_SUPERCEDE;
}
 
public UstawPerk(id, perk, wartosc, pokaz_info, lp)
{
   if(!ilosc_perkow)
      return PLUGIN_CONTINUE;
 
   static obroty[33];
 
   if(obroty[id]++ >= 5)
   {
      obroty[id] = 0;
      UstawPerk(id, 0, 0, 0, lp);
      return PLUGIN_CONTINUE;
   }
 
   perk = (perk == -1)? random_num(1, ilosc_perkow): perk;
   if(perk == perk_gracza[!lp][id] && perk)
   {
      UstawPerk(id, perk, wartosc, pokaz_info, lp);
      return PLUGIN_CONTINUE;
   }
   wartosc = (wartosc == -1 || min_wartosci_perkow[perk] > wartosc ||  wartosc > max_wartosci_perkow[perk])? random_num(min_wartosci_perkow[perk], max_wartosci_perkow[perk]): wartosc;
 
   new ret;
 
   new forward_handle = CreateOneForward(pluginy_perkow[perk_gracza[lp][id]], "cod_perk_disabled", FP_CELL, FP_CELL);
   ExecuteForward(forward_handle, ret, id, perk);
   DestroyForward(forward_handle);
 
   perk_gracza[lp][id] = 0;
 
   forward_handle = CreateOneForward(pluginy_perkow[perk], "cod_perk_enabled", FP_CELL, FP_CELL, FP_CELL);
   ExecuteForward(forward_handle, ret, id, wartosc, perk);
   DestroyForward(forward_handle);
 
   if(ret == 4)
   {
      UstawPerk(id, -1, -1, 1, lp);
      return PLUGIN_CONTINUE;
   }
 
   ExecuteForward( perk_zmieniony, ret, id, perk, wartosc, lp);
 
   if(ret == 4)
   {
      UstawPerk(id, -1, -1, 1, lp);
      return PLUGIN_CONTINUE;
   }
 
   obroty[id] = 0;
   if(pokaz_info &&  perk)
      client_print(id, print_chat, "[COD:MW3] Zdobyles %s.", nazwy_perkow[perk]);
 
   perk_gracza[lp][id] = perk;   
   wartosc_perku_gracza[lp][id] = wartosc;
   return PLUGIN_CONTINUE;
}
 
public UstawDoswiadczenie(id, wartosc)
{
   doswiadczenie_gracza[id] = wartosc;
   SprawdzPoziom(id);
}
 
public UstawKlase(id, klasa, zmien)
{
   nowa_klasa_gracza[id] = klasa;
   if(zmien)
   {
      UstawNowaKlase(id);
      DajBronie(id);
      ZastosujAtrybuty(id);
   }
}
 
public UstawTarcze(id, wartosc)
{
   if((gracz_ma_tarcze[id] = (wartosc > 0)))
      fm_give_item(id, "weapon_shield");
}
 
public UstawNoktowizor(id, wartosc)
{
   if((gracz_ma_noktowizor[id] = (wartosc > 0)))
      cs_set_user_nvg(id, 1);
}
 
public DajBron(id, bron)
{
   bonusowe_bronie_gracza[id] |= (1<<bron);
   new weaponname[22];
   get_weaponname(bron, weaponname, 21);
   return fm_give_item(id, weaponname);
}
 
public WezBron(id, bron)
{
   bonusowe_bronie_gracza[id] &= ~(1<<bron);
 
   if((1<<bron) & (bronie_dozwolone | bronie_klasy[get_user_team(id)] | bronie_klasy[klasa_gracza[id]])) 
      return;
 
   new weaponname[22];
   get_weaponname(bron, weaponname, 21);
   if(!((1<<bron) & (1<<CSW_HEGRENADE | 1<<CSW_SMOKEGRENADE | 1<<CSW_FLASHBANG)))
      engclient_cmd(id, "drop", weaponname);
}
 
public UstawBonusoweZdrowie(id, wartosc)
   bonusowe_zdrowie_gracza[id] = wartosc;
 
 
public UstawBonusowaInteligencje(id, wartosc)
   bonusowa_inteligencja_gracza[id] = wartosc;
 
 
public UstawBonusowaKondycje(id, wartosc)
   bonusowa_kondycja_gracza[id] = wartosc;
 
 
public UstawBonusowaWytrzymalosc(id, wartosc)
   bonusowa_wytrzymalosc_gracza[id] = wartosc;
 
 
public UstawBonusowaGrawitacje(id, wartosc)
   bonusowa_grawitacja_gracza[id] = wartosc;
 
public PrzydzielZdrowie(id, wartosc)
{
   new max_statystyka = get_pcvar_num(cvar_limit_poziomu)/2;
   wartosc = min(min(punkty_gracza[id], wartosc), max_statystyka-zdrowie_gracza[id]);
 
   punkty_gracza[id] -= wartosc;
   zdrowie_gracza[id] += wartosc;
}
 
public PrzydzielInteligencje(id, wartosc)
{
   new max_statystyka = get_pcvar_num(cvar_limit_poziomu)/2;
   wartosc = min(min(punkty_gracza[id], wartosc), max_statystyka-inteligencja_gracza[id]);
 
   punkty_gracza[id] -= wartosc;
   inteligencja_gracza[id] += wartosc;
}
 
public PrzydzielKondycje(id, wartosc)
{
   new max_statystyka = get_pcvar_num(cvar_limit_poziomu)/2;
   wartosc = min(min(punkty_gracza[id], wartosc), max_statystyka-kondycja_gracza[id]);
 
   punkty_gracza[id] -= wartosc;
   kondycja_gracza[id] += wartosc;
}
 
public PrzydzielWytrzymalosc(id, wartosc)
{
   new max_statystyka = get_pcvar_num(cvar_limit_poziomu)/2;
   wartosc = min(min(punkty_gracza[id], wartosc), max_statystyka-wytrzymalosc_gracza[id]);
 
   punkty_gracza[id] -= wartosc;
   wytrzymalosc_gracza[id] += wartosc;
}
 
public PrzydzielGrawitacje(id, wartosc)
{
   new max_statystyka = get_pcvar_num(cvar_limit_poziomu);
   wartosc = min(min(punkty_gracza[id], wartosc), max_statystyka-grawitacja_gracza[id]);
 
   punkty_gracza[id] -= wartosc;
   grawitacja_gracza[id] += wartosc;
}
 
public PobierzPerk(plugin, params)
{
   if(params != 3)
      return 0;
 
   new id = get_param(1), lp = get_param(3);
   set_param_byref(2, wartosc_perku_gracza[lp][id]);
   return perk_gracza[lp][id];
}
 
public PobierzIloscPerkow()
   return ilosc_perkow;
 
 
public PobierzNazwePerku(perk, Return[], len)
{
   if(perk <= ilosc_perkow)
   {
      param_convert(2);
      copy(Return, len, nazwy_perkow[perk]);
   }
}
 
public PobierzOpisPerku(perk, Return[], len)
{
   if(perk <= ilosc_perkow)
   {
      param_convert(2);
      copy(Return, len, opisy_perkow[perk]);
   }
}
 
public PobierzPerkPrzezNazwe(const nazwa[])
{
   param_convert(1);
   for(new i=1; i <= ilosc_perkow; i++)
      if(equal(nazwa, nazwy_perkow[i]))
      return i;
   return 0;
}
 
public PobierzDoswiadczeniePoziomu(poziom)
   return power(poziom, 2)*get_pcvar_num(cvar_proporcja_poziomu);
 
public PobierzDoswiadczenie(id)
   return doswiadczenie_gracza[id];
 
public PobierzPunkty(id)
   return punkty_gracza[id];
 
public PobierzPoziom(id)
   return poziom_gracza[id];
 
public PobierzZdrowie(id, zdrowie_zdobyte, zdrowie_klasy, zdrowie_bonusowe)
{
   new zdrowie;
 
   if(zdrowie_zdobyte)
      zdrowie += zdrowie_gracza[id];
   if(zdrowie_bonusowe)
      zdrowie += bonusowe_zdrowie_gracza[id];
   if(zdrowie_klasy)
      zdrowie += zdrowie_klas[klasa_gracza[id]];
 
   return zdrowie;
}
 
public PobierzInteligencje(id, inteligencja_zdobyta, inteligencja_klasy, inteligencja_bonusowa)
{
   new inteligencja;
 
   if(inteligencja_zdobyta)
      inteligencja += inteligencja_gracza[id];
   if(inteligencja_bonusowa)
      inteligencja += bonusowa_inteligencja_gracza[id];
   if(inteligencja_klasy)
      inteligencja += inteligencja_klas[klasa_gracza[id]];
 
   return inteligencja;
}
 
public PobierzKondycje(id, kondycja_zdobyta, kondycja_klasy, kondycja_bonusowa)
{
   new kondycja;
 
   if(kondycja_zdobyta)
      kondycja += kondycja_gracza[id];
   if(kondycja_bonusowa)
      kondycja += bonusowa_kondycja_gracza[id];
   if(kondycja_klasy)
      kondycja += kondycja_klas[klasa_gracza[id]];
 
   return kondycja;
}
 
public PobierzWytrzymalosc(id, wytrzymalosc_zdobyta, wytrzymalosc_klasy, wytrzymalosc_bonusowa)
{
   new wytrzymalosc;
 
   if(wytrzymalosc_zdobyta)
      wytrzymalosc += wytrzymalosc_gracza[id];
   if(wytrzymalosc_bonusowa)
      wytrzymalosc += bonusowa_wytrzymalosc_gracza[id];
   if(wytrzymalosc_klasy)
      wytrzymalosc += wytrzymalosc_klas[klasa_gracza[id]];
 
   return wytrzymalosc;
}
 
public PobierzGrawitacje(id, grawitacja_zdobyta, grawitacja_klasy, grawitacja_bonusowa)
{
   new grawitacja;
 
   if(grawitacja_zdobyta)
      grawitacja += grawitacja_gracza[id];
   if(grawitacja_bonusowa)
      grawitacja += bonusowa_grawitacja_gracza[id];
   if(grawitacja_klasy)
      grawitacja += grawitacja_klas[klasa_gracza[id]];
 
   return grawitacja;
}
 
public PobierzKlase(id)
   return klasa_gracza[id];
 
public PobierzIloscKlas()
   return ilosc_klas;
 
public PobierzNazweKlasy(klasa, Return[], len)
{
   if(klasa <= ilosc_klas)
   {
      param_convert(2);
      copy(Return, len, nazwy_klas[klasa]);
   }
}
 
public PobierzOpisKlasy(klasa, Return[], len)
{
   if(klasa <= ilosc_klas)
   {
      param_convert(2);
      copy(Return, len, opisy_klas[klasa]);
   }
}
 
public PobierzKlasePrzezNazwe(const nazwa[])
{
   param_convert(1);
   for(new i=1; i <= ilosc_klas; i++)
      if(equal(nazwa, nazwy_klas[i]))
      return i;
   return 0;
}
 
public PobierzZdrowieKlasy(klasa)
{
   if(klasa <= ilosc_klas)
      return zdrowie_klas[klasa];
   return -1;
}
 
public PobierzInteligencjeKlasy(klasa)
{
   if(klasa <= ilosc_klas)
      return inteligencja_klas[klasa];
   return -1;
}
 
public PobierzKondycjeKlasy(klasa)
{
   if(klasa <= ilosc_klas)
      return kondycja_klas[klasa];
   return -1;
}
 
public PobierzWytrzymaloscKlasy(klasa)
{
   if(klasa <= ilosc_klas)
      return wytrzymalosc_klas[klasa];
   return -1;
}
 
public PobierzGrawitacjeKlasy(klasa)
{
   if(klasa <= ilosc_klas)
      return grawitacja_klas[klasa];
   return -1;
}
 
public ZadajObrazenia(atakujacy, ofiara, Float:obrazenia, Float:czynnik_inteligencji, byt_uszkadzajacy, dodatkowe_flagi)
   ExecuteHam(Ham_TakeDamage, ofiara, byt_uszkadzajacy, atakujacy, obrazenia+PobierzInteligencje(atakujacy, 1, 1, 1)*czynnik_inteligencji, (1<<31) | dodatkowe_flagi);
 
public ZarejestrujPerk(plugin, params)
{
   if(params != 4)
      return PLUGIN_CONTINUE;
 
   if(++ilosc_perkow > MAX_ILOSC_PERKOW)
      return -1;
 
   pluginy_perkow[ilosc_perkow] = plugin;
   get_string(1, nazwy_perkow[ilosc_perkow], MAX_WIELKOSC_NAZWY);
   get_string(2, opisy_perkow[ilosc_perkow], MAX_WIELKOSC_OPISU);
   min_wartosci_perkow[ilosc_perkow] = get_param(3);
   max_wartosci_perkow[ilosc_perkow] = get_param(4);
 
   return ilosc_perkow;
}
 
public ZarejestrujKlase(plugin, params)
{
   if(params != 8)
      return PLUGIN_CONTINUE;
 
   if(++ilosc_klas > MAX_ILOSC_KLAS)
      return -1;
 
   pluginy_klas[ilosc_klas] = plugin;
 
   get_string(1, nazwy_klas[ilosc_klas], MAX_WIELKOSC_NAZWY);
   get_string(2, opisy_klas[ilosc_klas], MAX_WIELKOSC_OPISU);
 
   bronie_klasy[ilosc_klas] = get_param(3);
   zdrowie_klas[ilosc_klas] = get_param(4);
   kondycja_klas[ilosc_klas] = get_param(5);
   inteligencja_klas[ilosc_klas] = get_param(6);
   wytrzymalosc_klas[ilosc_klas] = get_param(7);
   grawitacja_klas[ilosc_klas] = get_param(8);
   for(new i=0;i<klasid;i++){
      if(equali(nazwy_klas[ilosc_klas],nazwa_klasy[i])){
         frakcja_klas[ilosc_klas] = nazwa_frakcji[i];
      }
   }
 
   return ilosc_klas;
}
 
stock ham_strip_weapon(id, weapon[])
{
   if(!equal(weapon, "weapon_", 7) ) return 0
   new wId = get_weaponid(weapon)
   if(!wId) return 0
   new wEnt
   while( (wEnt = engfunc(EngFunc_FindEntityByString,wEnt,"classname", weapon) ) && pev(wEnt, pev_owner) != id) {}
   if(!wEnt) return 0
 
   if(get_user_weapon(id) == wId) ExecuteHamB(Ham_Weapon_RetireWeapon, wEnt)
 
   if(!ExecuteHamB(Ham_RemovePlayerItem, id, wEnt)) return 0
   ExecuteHamB(Ham_Item_Kill ,wEnt)
 
   set_pev(id, pev_weapons, pev(id, pev_weapons) & ~(1<<wId) )
   return 1
}
 
stock Display_Fade(id,duration,holdtime,fadetype,red,green,blue,alpha)
{
   message_begin( MSG_ONE, MsgScreenfade,{0,0,0},id );
   write_short( duration );   // Duration of fadeout
   write_short( holdtime );   // Hold time of color
   write_short( fadetype );   // Fade type
   write_byte ( red );      // Red
   write_byte ( green );      // Green
   write_byte ( blue );      // Blue
   write_byte ( alpha );   // Alpha
   message_end();
}
 
stock fm_give_item(index, const item[]) {
   if (!equal(item, "weapon_", 7) && !equal(item, "ammo_", 5) && !equal(item, "item_", 5) && !equal(item, "tf_weapon_", 10))
      return 0;
 
   new ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, item));
   if (!pev_valid(ent))
      return 0;
 
   new Float:origin[3];
   pev(index, pev_origin, origin);
   set_pev(ent, pev_origin, origin);
   set_pev(ent, pev_spawnflags, pev(ent, pev_spawnflags) | SF_NORESPAWN);
   dllfunc(DLLFunc_Spawn, ent);
 
   new save = pev(ent, pev_solid);
   dllfunc(DLLFunc_Touch, ent, index);
   if (pev(ent, pev_solid) != save)
      return ent;
 
   engfunc(EngFunc_RemoveEntity, ent);
 
   return -1;
}
 
public BlokujKomende()
   return PLUGIN_HANDLED;
 
public ZarejestrujAwans(plugin, params)
{
   if(params != 10)
      return PLUGIN_CONTINUE;
 
   if(++ilosc_klas > MAX_ILOSC_KLAS)
      return -1;
 
   pluginy_klas[ilosc_klas] = plugin;
 
   new awans_z = get_param(1);
   awansuje_do[awans_z] = ilosc_klas;
   awansuje_z[ilosc_klas] = awans_z;
   ilosc_awansow++;
   awanse[ilosc_awansow][1] = ilosc_klas;
   awanse[ilosc_awansow][0] = awans_z;
   awanse[ilosc_awansow][2] = get_param(2);
   get_string(3, nazwy_klas[ilosc_klas], MAX_WIELKOSC_NAZWY);
   get_string(4, opisy_klas[ilosc_klas], MAX_WIELKOSC_OPISU);
 
   bronie_klasy[ilosc_klas] = get_param(5);
   zdrowie_klas[ilosc_klas] = get_param(6);
   kondycja_klas[ilosc_klas] = get_param(7);
   inteligencja_k